Mercurial > pidgin

comparison src/protocols/oscar/bstream.c @ 13239:f260d319bbbc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 15605] Renaming a bunch of structs and typedefs to use the same naming scheme as the rest of Gaim committer: Tailor Script <tailor@pidgin.im>
author Mark Doliner <mark@kingant.net>
date Sun, 12 Feb 2006 16:02:05 +0000
parents f2431a7e33aa
children 6519aeb66b31
comparison
equal deleted inserted replaced
13238:1e855032d7bc 13239:f260d319bbbc
22 * This file contains all functions needed to use bstreams. 22 * This file contains all functions needed to use bstreams.
23 */ 23 */
24 24
25 #include "oscar.h" 25 #include "oscar.h"
26 26
27 faim_internal int aim_bstream_init(aim_bstream_t *bs, guint8 *data, int len) 27 faim_internal int aim_bstream_init(ByteStream *bs, guint8 *data, int len)
28 { 28 {
29 29
30 if (!bs) 30 if (!bs)
31 return -1; 31 return -1;
32 32
35 bs->offset = 0; 35 bs->offset = 0;
36 36
37 return 0; 37 return 0;
38 } 38 }
39 39
40 faim_internal int aim_bstream_empty(aim_bstream_t *bs) 40 faim_internal int aim_bstream_empty(ByteStream *bs)
41 { 41 {
42 return bs->len - bs->offset; 42 return bs->len - bs->offset;
43 } 43 }
44 44
45 faim_internal int aim_bstream_curpos(aim_bstream_t *bs) 45 faim_internal int aim_bstream_curpos(ByteStream *bs)
46 { 46 {
47 return bs->offset; 47 return bs->offset;
48 } 48 }
49 49
50 faim_internal int aim_bstream_setpos(aim_bstream_t *bs, unsigned int off) 50 faim_internal int aim_bstream_setpos(ByteStream *bs, unsigned int off)
51 { 51 {
52 52
53 if (off > bs->len) 53 if (off > bs->len)
54 return -1; 54 return -1;
55 55
56 bs->offset = off; 56 bs->offset = off;
57 57
58 return off; 58 return off;
59 } 59 }
60 60
61 faim_internal void aim_bstream_rewind(aim_bstream_t *bs) 61 faim_internal void aim_bstream_rewind(ByteStream *bs)
62 { 62 {
63 63
64 aim_bstream_setpos(bs, 0); 64 aim_bstream_setpos(bs, 0);
65 65
66 return; 66 return;
69 /* 69 /*
70 * N can be negative, which can be used for going backwards 70 * N can be negative, which can be used for going backwards
71 * in a bstream. I'm not sure if libfaim actually does 71 * in a bstream. I'm not sure if libfaim actually does
72 * this anywhere... 72 * this anywhere...
73 */ 73 */
74 faim_internal int aim_bstream_advance(aim_bstream_t *bs, int n) 74 faim_internal int aim_bstream_advance(ByteStream *bs, int n)
75 { 75 {
76 76
77 if ((aim_bstream_curpos(bs) + n < 0) || (aim_bstream_empty(bs) < n)) 77 if ((aim_bstream_curpos(bs) + n < 0) || (aim_bstream_empty(bs) < n))
78 return 0; /* XXX throw an exception */ 78 return 0; /* XXX throw an exception */
79 79
80 bs->offset += n; 80 bs->offset += n;
81 81
82 return n; 82 return n;
83 } 83 }
84 84
85 faim_internal guint8 aimbs_get8(aim_bstream_t *bs) 85 faim_internal guint8 aimbs_get8(ByteStream *bs)
86 { 86 {
87 87
88 if (aim_bstream_empty(bs) < 1) 88 if (aim_bstream_empty(bs) < 1)
89 return 0; /* XXX throw an exception */ 89 return 0; /* XXX throw an exception */
90 90
91 bs->offset++; 91 bs->offset++;
92 92
93 return aimutil_get8(bs->data + bs->offset - 1); 93 return aimutil_get8(bs->data + bs->offset - 1);
94 } 94 }
95 95
96 faim_internal guint16 aimbs_get16(aim_bstream_t *bs) 96 faim_internal guint16 aimbs_get16(ByteStream *bs)
97 { 97 {
98 98
99 if (aim_bstream_empty(bs) < 2) 99 if (aim_bstream_empty(bs) < 2)
100 return 0; /* XXX throw an exception */ 100 return 0; /* XXX throw an exception */
101 101
102 bs->offset += 2; 102 bs->offset += 2;
103 103
104 return aimutil_get16(bs->data + bs->offset - 2); 104 return aimutil_get16(bs->data + bs->offset - 2);
105 } 105 }
106 106
107 faim_internal guint32 aimbs_get32(aim_bstream_t *bs) 107 faim_internal guint32 aimbs_get32(ByteStream *bs)
108 { 108 {
109 109
110 if (aim_bstream_empty(bs) < 4) 110 if (aim_bstream_empty(bs) < 4)
111 return 0; /* XXX throw an exception */ 111 return 0; /* XXX throw an exception */
112 112
113 bs->offset += 4; 113 bs->offset += 4;
114 114
115 return aimutil_get32(bs->data + bs->offset - 4); 115 return aimutil_get32(bs->data + bs->offset - 4);
116 } 116 }
117 117
118 faim_internal guint8 aimbs_getle8(aim_bstream_t *bs) 118 faim_internal guint8 aimbs_getle8(ByteStream *bs)
119 { 119 {
120 120
121 if (aim_bstream_empty(bs) < 1) 121 if (aim_bstream_empty(bs) < 1)
122 return 0; /* XXX throw an exception */ 122 return 0; /* XXX throw an exception */
123 123
124 bs->offset++; 124 bs->offset++;
125 125
126 return aimutil_getle8(bs->data + bs->offset - 1); 126 return aimutil_getle8(bs->data + bs->offset - 1);
127 } 127 }
128 128
129 faim_internal guint16 aimbs_getle16(aim_bstream_t *bs) 129 faim_internal guint16 aimbs_getle16(ByteStream *bs)
130 { 130 {
131 131
132 if (aim_bstream_empty(bs) < 2) 132 if (aim_bstream_empty(bs) < 2)
133 return 0; /* XXX throw an exception */ 133 return 0; /* XXX throw an exception */
134 134
135 bs->offset += 2; 135 bs->offset += 2;
136 136
137 return aimutil_getle16(bs->data + bs->offset - 2); 137 return aimutil_getle16(bs->data + bs->offset - 2);
138 } 138 }
139 139
140 faim_internal guint32 aimbs_getle32(aim_bstream_t *bs) 140 faim_internal guint32 aimbs_getle32(ByteStream *bs)
141 { 141 {
142 142
143 if (aim_bstream_empty(bs) < 4) 143 if (aim_bstream_empty(bs) < 4)
144 return 0; /* XXX throw an exception */ 144 return 0; /* XXX throw an exception */
145 145
146 bs->offset += 4; 146 bs->offset += 4;
147 147
148 return aimutil_getle32(bs->data + bs->offset - 4); 148 return aimutil_getle32(bs->data + bs->offset - 4);
149 } 149 }
150 150
151 faim_internal int aimbs_getrawbuf(aim_bstream_t *bs, guint8 *buf, int len) 151 faim_internal int aimbs_getrawbuf(ByteStream *bs, guint8 *buf, int len)
152 { 152 {
153 153
154 if (aim_bstream_empty(bs) < len) 154 if (aim_bstream_empty(bs) < len)
155 return 0; 155 return 0;
156 156
158 bs->offset += len; 158 bs->offset += len;
159 159
160 return len; 160 return len;
161 } 161 }
162 162
163 faim_internal guint8 *aimbs_getraw(aim_bstream_t *bs, int len) 163 faim_internal guint8 *aimbs_getraw(ByteStream *bs, int len)
164 { 164 {
165 guint8 *ob; 165 guint8 *ob;
166 166
167 if (!(ob = malloc(len))) 167 if (!(ob = malloc(len)))
168 return NULL; 168 return NULL;
173 } 173 }
174 174
175 return ob; 175 return ob;
176 } 176 }
177 177
178 faim_internal char *aimbs_getstr(aim_bstream_t *bs, int len) 178 faim_internal char *aimbs_getstr(ByteStream *bs, int len)
179 { 179 {
180 char *ob; 180 char *ob;
181 181
182 if (!(ob = malloc(len + 1))) 182 if (!(ob = malloc(len + 1)))
183 return NULL; 183 return NULL;
190 ob[len] = '\0'; 190 ob[len] = '\0';
191 191
192 return ob; 192 return ob;
193 } 193 }
194 194
195 faim_internal int aimbs_put8(aim_bstream_t *bs, guint8 v) 195 faim_internal int aimbs_put8(ByteStream *bs, guint8 v)
196 { 196 {
197 197
198 if (aim_bstream_empty(bs) < 1) 198 if (aim_bstream_empty(bs) < 1)
199 return 0; /* XXX throw an exception */ 199 return 0; /* XXX throw an exception */
200 200
201 bs->offset += aimutil_put8(bs->data + bs->offset, v); 201 bs->offset += aimutil_put8(bs->data + bs->offset, v);
202 202
203 return 1; 203 return 1;
204 } 204 }
205 205
206 faim_internal int aimbs_put16(aim_bstream_t *bs, guint16 v) 206 faim_internal int aimbs_put16(ByteStream *bs, guint16 v)
207 { 207 {
208 208
209 if (aim_bstream_empty(bs) < 2) 209 if (aim_bstream_empty(bs) < 2)
210 return 0; /* XXX throw an exception */ 210 return 0; /* XXX throw an exception */
211 211
212 bs->offset += aimutil_put16(bs->data + bs->offset, v); 212 bs->offset += aimutil_put16(bs->data + bs->offset, v);
213 213
214 return 2; 214 return 2;
215 } 215 }
216 216
217 faim_internal int aimbs_put32(aim_bstream_t *bs, guint32 v) 217 faim_internal int aimbs_put32(ByteStream *bs, guint32 v)
218 { 218 {
219 219
220 if (aim_bstream_empty(bs) < 4) 220 if (aim_bstream_empty(bs) < 4)
221 return 0; /* XXX throw an exception */ 221 return 0; /* XXX throw an exception */
222 222
223 bs->offset += aimutil_put32(bs->data + bs->offset, v); 223 bs->offset += aimutil_put32(bs->data + bs->offset, v);
224 224
225 return 1; 225 return 1;
226 } 226 }
227 227
228 faim_internal int aimbs_putle8(aim_bstream_t *bs, guint8 v) 228 faim_internal int aimbs_putle8(ByteStream *bs, guint8 v)
229 { 229 {
230 230
231 if (aim_bstream_empty(bs) < 1) 231 if (aim_bstream_empty(bs) < 1)
232 return 0; /* XXX throw an exception */ 232 return 0; /* XXX throw an exception */
233 233
234 bs->offset += aimutil_putle8(bs->data + bs->offset, v); 234 bs->offset += aimutil_putle8(bs->data + bs->offset, v);
235 235
236 return 1; 236 return 1;
237 } 237 }
238 238
239 faim_internal int aimbs_putle16(aim_bstream_t *bs, guint16 v) 239 faim_internal int aimbs_putle16(ByteStream *bs, guint16 v)
240 { 240 {
241 241
242 if (aim_bstream_empty(bs) < 2) 242 if (aim_bstream_empty(bs) < 2)
243 return 0; /* XXX throw an exception */ 243 return 0; /* XXX throw an exception */
244 244
245 bs->offset += aimutil_putle16(bs->data + bs->offset, v); 245 bs->offset += aimutil_putle16(bs->data + bs->offset, v);
246 246
247 return 2; 247 return 2;
248 } 248 }
249 249
250 faim_internal int aimbs_putle32(aim_bstream_t *bs, guint32 v) 250 faim_internal int aimbs_putle32(ByteStream *bs, guint32 v)
251 { 251 {
252 252
253 if (aim_bstream_empty(bs) < 4) 253 if (aim_bstream_empty(bs) < 4)
254 return 0; /* XXX throw an exception */ 254 return 0; /* XXX throw an exception */
255 255
257 257
258 return 1; 258 return 1;
259 } 259 }
260 260
261 261
262 faim_internal int aimbs_putraw(aim_bstream_t *bs, const guint8 *v, int len) 262 faim_internal int aimbs_putraw(ByteStream *bs, const guint8 *v, int len)
263 { 263 {
264 264
265 if (aim_bstream_empty(bs) < len) 265 if (aim_bstream_empty(bs) < len)
266 return 0; /* XXX throw an exception */ 266 return 0; /* XXX throw an exception */
267 267
269 bs->offset += len; 269 bs->offset += len;
270 270
271 return len; 271 return len;
272 } 272 }
273 273
274 faim_internal int aimbs_putstr(aim_bstream_t *bs, const char *str) 274 faim_internal int aimbs_putstr(ByteStream *bs, const char *str)
275 { 275 {
276 return aimbs_putraw(bs, (guint8 *)str, strlen(str)); 276 return aimbs_putraw(bs, (guint8 *)str, strlen(str));
277 } 277 }
278 278
279 faim_internal int aimbs_putbs(aim_bstream_t *bs, aim_bstream_t *srcbs, int len) 279 faim_internal int aimbs_putbs(ByteStream *bs, ByteStream *srcbs, int len)
280 { 280 {
281 281
282 if (aim_bstream_empty(srcbs) < len) 282 if (aim_bstream_empty(srcbs) < len)
283 return 0; /* XXX throw exception (underrun) */ 283 return 0; /* XXX throw exception (underrun) */
284 284