← Back to branch summary

~lightdm-team/lightdm/1.4

« back to all changes in this revision

Viewing changes to tests/src/x-common.c

  • Committer: Robert Ancell
  • Date: 2014-03-13 02:15:38 UTC
  • Revision ID: robert.ancell@canonical.com-20140313021538-u2mxfxrrfw5u58ic
Tags: 1.4.7
Releasing 1.4.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/src/x-common.c
 
1
#include <string.h>
 
2
 
 
3
#include "x-common.h"
 
4
 
 
5
gsize
 
6
pad (gsize length)
 
7
{
 
8
    if (length % 4 == 0)
 
9
        return 0;
 
10
    return 4 - length % 4;
 
11
}
 
12
 
 
13
void
 
14
read_padding (gsize length, gsize *offset)
 
15
{
 
16
    *offset += length;
 
17
}
 
18
 
 
19
guint8
 
20
read_card8 (const guint8 *buffer, gsize buffer_length, gsize *offset)
 
21
{
 
22
    if (*offset >= buffer_length)
 
23
        return 0;
 
24
    (*offset)++;
 
25
    return buffer[*offset - 1];
 
26
}
 
27
 
 
28
guint16
 
29
read_card16 (const guint8 *buffer, gsize buffer_length, guint8 byte_order, gsize *offset)
 
30
{
 
31
    guint8 a, b;
 
32
 
 
33
    a = read_card8 (buffer, buffer_length, offset);
 
34
    b = read_card8 (buffer, buffer_length, offset);
 
35
    if (byte_order == X_BYTE_ORDER_MSB)
 
36
        return a << 8 | b;
 
37
    else
 
38
        return b << 8 | a;
 
39
}
 
40
 
 
41
guint32
 
42
read_card32 (const guint8 *buffer, gsize buffer_length, guint8 byte_order, gsize *offset)
 
43
{
 
44
    guint8 a, b, c, d;
 
45
 
 
46
    a = read_card8 (buffer, buffer_length, offset);
 
47
    b = read_card8 (buffer, buffer_length, offset);
 
48
    c = read_card8 (buffer, buffer_length, offset);
 
49
    d = read_card8 (buffer, buffer_length, offset);
 
50
    if (byte_order == X_BYTE_ORDER_MSB)
 
51
        return a << 24 | b << 16 | c << 8 | d;
 
52
    else
 
53
        return d << 24 | c << 16 | b << 8 | a;
 
54
}
 
55
 
 
56
guint8 *
 
57
read_string8 (const guint8 *buffer, gsize buffer_length, gsize string_length, gsize *offset)
 
58
{
 
59
    guint8 *string;
 
60
    int i;
 
61
 
 
62
    string = g_malloc (string_length + 1);
 
63
    for (i = 0; i < string_length; i++)
 
64
        string[i] = read_card8 (buffer, buffer_length, offset);
 
65
    string[i] = '\0';
 
66
    return string;
 
67
}
 
68
 
 
69
gchar *
 
70
read_string (const guint8 *buffer, gsize buffer_length, gsize string_length, gsize *offset)
 
71
{
 
72
    return (gchar *) read_string8 (buffer, buffer_length, string_length, offset);
 
73
}
 
74
 
 
75
gchar *
 
76
read_padded_string (const guint8 *buffer, gsize buffer_length, gsize string_length, gsize *offset)
 
77
{
 
78
    guint8 *value;
 
79
    value = read_string8 (buffer, buffer_length, string_length, offset);
 
80
    read_padding (pad (string_length), offset);
 
81
    return (gchar *) value;
 
82
}
 
83
 
 
84
void
 
85
write_card8 (guint8 *buffer, gsize buffer_length, guint8 value, gsize *offset)
 
86
{
 
87
    if (*offset >= buffer_length)
 
88
        return;
 
89
    buffer[*offset] = value;
 
90
    (*offset)++;
 
91
}
 
92
 
 
93
void
 
94
write_padding (guint8 *buffer, gsize buffer_length, gsize length, gsize *offset)
 
95
{
 
96
    gsize i;
 
97
    for (i = 0; i < length; i++)
 
98
        write_card8 (buffer, buffer_length, 0, offset);
 
99
}
 
100
 
 
101
void
 
102
write_card16 (guint8 *buffer, gsize buffer_length, guint8 byte_order, guint16 value, gsize *offset)
 
103
{
 
104
    if (byte_order == X_BYTE_ORDER_MSB)
 
105
    {
 
106
        write_card8 (buffer, buffer_length, value >> 8, offset);
 
107
        write_card8 (buffer, buffer_length, value & 0xFF, offset);
 
108
    }
 
109
    else
 
110
    {
 
111
        write_card8 (buffer, buffer_length, value & 0xFF, offset);
 
112
        write_card8 (buffer, buffer_length, value >> 8, offset);
 
113
    }
 
114
}
 
115
 
 
116
void
 
117
write_card32 (guint8 *buffer, gsize buffer_length, guint8 byte_order, guint32 value, gsize *offset)
 
118
{
 
119
    if (byte_order == X_BYTE_ORDER_MSB)
 
120
    {
 
121
        write_card8 (buffer, buffer_length, value >> 24, offset);
 
122
        write_card8 (buffer, buffer_length, (value >> 16) & 0xFF, offset);
 
123
        write_card8 (buffer, buffer_length, (value >> 8) & 0xFF, offset);
 
124
        write_card8 (buffer, buffer_length, value & 0xFF, offset);
 
125
    }
 
126
    else
 
127
    {
 
128
        write_card8 (buffer, buffer_length, value & 0xFF, offset);
 
129
        write_card8 (buffer, buffer_length, (value >> 8) & 0xFF, offset);
 
130
        write_card8 (buffer, buffer_length, (value >> 16) & 0xFF, offset);
 
131
        write_card8 (buffer, buffer_length, value >> 24, offset);
 
132
    }
 
133
}
 
134
 
 
135
void
 
136
write_string8 (guint8 *buffer, gsize buffer_length, const guint8 *value, gsize value_length, gsize *offset)
 
137
{
 
138
    gsize i;
 
139
    for (i = 0; i < value_length; i++)
 
140
        write_card8 (buffer, buffer_length, value[i], offset);
 
141
}
 
142
 
 
143
gsize
 
144
padded_string_length (const gchar *value)
 
145
{
 
146
    return (strlen (value) + pad (strlen (value))) / 4;
 
147
}
 
148
 
 
149
void
 
150
write_string (guint8 *buffer, gsize buffer_length, const gchar *value, gsize *offset)
 
151
{
 
152
    write_string8 (buffer, buffer_length, (guint8 *) value, strlen (value), offset);
 
153
}
 
154
 
 
155
void
 
156
write_padded_string (guint8 *buffer, gsize buffer_length, const gchar *value, gsize *offset)
 
157
{
 
158
    write_string8 (buffer, buffer_length, (guint8 *) value, strlen (value), offset);
 
159
    write_padding (buffer, buffer_length, pad (strlen (value)), offset);
 
160
}