comparison: libpurple/protocols/oscar/bstream.c
libpurple/protocols/oscar/bstream.c
- changeset 40072
- 67e558b6711b
- parent 40065
- 3b61e89f42bd
- parent 40071
- 148d89dee247
- child 40076
- 432bd1f3748f
equal
deleted
inserted
replaced
| 40065:3b61e89f42bd | 40072:67e558b6711b |
|---|---|
| 1 /* | |
| 2 * Purple's oscar protocol plugin | |
| 3 * This file is the legal property of its developers. | |
| 4 * Please see the AUTHORS file distributed alongside this file. | |
| 5 * | |
| 6 * This library is free software; you can redistribute it and/or | |
| 7 * modify it under the terms of the GNU Lesser General Public | |
| 8 * License as published by the Free Software Foundation; either | |
| 9 * version 2 of the License, or (at your option) any later version. | |
| 10 * | |
| 11 * This library is distributed in the hope that it will be useful, | |
| 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 14 * Lesser General Public License for more details. | |
| 15 * | |
| 16 * You should have received a copy of the GNU Lesser General Public | |
| 17 * License along with this library; if not, write to the Free Software | |
| 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA | |
| 19 */ | |
| 20 | |
| 21 /* | |
| 22 * This file contains all functions needed to use bstreams. | |
| 23 */ | |
| 24 | |
| 25 #include "oscar.h" | |
| 26 | |
| 27 int byte_stream_new(ByteStream *bs, size_t len) | |
| 28 { | |
| 29 if (bs == NULL) | |
| 30 return -1; | |
| 31 | |
| 32 return byte_stream_init(bs, g_malloc(len), len); | |
| 33 } | |
| 34 | |
| 35 int byte_stream_init(ByteStream *bs, guint8 *data, size_t len) | |
| 36 { | |
| 37 if (bs == NULL) | |
| 38 return -1; | |
| 39 | |
| 40 bs->data = data; | |
| 41 bs->len = len; | |
| 42 bs->offset = 0; | |
| 43 | |
| 44 return 0; | |
| 45 } | |
| 46 | |
| 47 void byte_stream_destroy(ByteStream *bs) | |
| 48 { | |
| 49 g_free(bs->data); | |
| 50 } | |
| 51 | |
| 52 size_t byte_stream_bytes_left(ByteStream *bs) | |
| 53 { | |
| 54 g_return_val_if_fail(bs != NULL, 0); | |
| 55 g_return_val_if_fail(bs->len >= bs->offset, 0); | |
| 56 | |
| 57 return bs->len - bs->offset; | |
| 58 } | |
| 59 | |
| 60 int byte_stream_curpos(ByteStream *bs) | |
| 61 { | |
| 62 return bs->offset; | |
| 63 } | |
| 64 | |
| 65 int byte_stream_setpos(ByteStream *bs, size_t off) | |
| 66 { | |
| 67 g_return_val_if_fail(off <= bs->len, -1); | |
| 68 | |
| 69 bs->offset = off; | |
| 70 return off; | |
| 71 } | |
| 72 | |
| 73 void byte_stream_rewind(ByteStream *bs) | |
| 74 { | |
| 75 byte_stream_setpos(bs, 0); | |
| 76 } | |
| 77 | |
| 78 /* | |
| 79 * N can be negative, which can be used for going backwards | |
| 80 * in a bstream. | |
| 81 */ | |
| 82 int byte_stream_advance(ByteStream *bs, int n) | |
| 83 { | |
| 84 g_return_val_if_fail(byte_stream_curpos(bs) + n >= 0, 0); | |
| 85 g_return_val_if_fail((gsize)n <= byte_stream_bytes_left(bs), 0); | |
| 86 | |
| 87 bs->offset += n; | |
| 88 return n; | |
| 89 } | |
| 90 | |
| 91 guint8 byte_stream_get8(ByteStream *bs) | |
| 92 { | |
| 93 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 1, 0); | |
| 94 | |
| 95 bs->offset++; | |
| 96 return aimutil_get8(bs->data + bs->offset - 1); | |
| 97 } | |
| 98 | |
| 99 guint16 byte_stream_get16(ByteStream *bs) | |
| 100 { | |
| 101 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 2, 0); | |
| 102 | |
| 103 bs->offset += 2; | |
| 104 return aimutil_get16(bs->data + bs->offset - 2); | |
| 105 } | |
| 106 | |
| 107 guint32 byte_stream_get32(ByteStream *bs) | |
| 108 { | |
| 109 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 4, 0); | |
| 110 | |
| 111 bs->offset += 4; | |
| 112 return aimutil_get32(bs->data + bs->offset - 4); | |
| 113 } | |
| 114 | |
| 115 guint8 byte_stream_getle8(ByteStream *bs) | |
| 116 { | |
| 117 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 1, 0); | |
| 118 | |
| 119 bs->offset++; | |
| 120 return aimutil_getle8(bs->data + bs->offset - 1); | |
| 121 } | |
| 122 | |
| 123 guint16 byte_stream_getle16(ByteStream *bs) | |
| 124 { | |
| 125 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 2, 0); | |
| 126 | |
| 127 bs->offset += 2; | |
| 128 return aimutil_getle16(bs->data + bs->offset - 2); | |
| 129 } | |
| 130 | |
| 131 guint32 byte_stream_getle32(ByteStream *bs) | |
| 132 { | |
| 133 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 4, 0); | |
| 134 | |
| 135 bs->offset += 4; | |
| 136 return aimutil_getle32(bs->data + bs->offset - 4); | |
| 137 } | |
| 138 | |
| 139 static void byte_stream_getrawbuf_nocheck(ByteStream *bs, guint8 *buf, size_t len) | |
| 140 { | |
| 141 memcpy(buf, bs->data + bs->offset, len); | |
| 142 bs->offset += len; | |
| 143 } | |
| 144 | |
| 145 int byte_stream_getrawbuf(ByteStream *bs, guint8 *buf, size_t len) | |
| 146 { | |
| 147 g_return_val_if_fail(byte_stream_bytes_left(bs) >= len, 0); | |
| 148 | |
| 149 byte_stream_getrawbuf_nocheck(bs, buf, len); | |
| 150 return len; | |
| 151 } | |
| 152 | |
| 153 guint8 *byte_stream_getraw(ByteStream *bs, size_t len) | |
| 154 { | |
| 155 guint8 *ob; | |
| 156 | |
| 157 g_return_val_if_fail(byte_stream_bytes_left(bs) >= len, NULL); | |
| 158 | |
| 159 ob = g_malloc(len); | |
| 160 byte_stream_getrawbuf_nocheck(bs, ob, len); | |
| 161 return ob; | |
| 162 } | |
| 163 | |
| 164 char *byte_stream_getstr(ByteStream *bs, size_t len) | |
| 165 { | |
| 166 char *ob; | |
| 167 | |
| 168 g_return_val_if_fail(byte_stream_bytes_left(bs) >= len, NULL); | |
| 169 | |
| 170 ob = g_malloc(len + 1); | |
| 171 byte_stream_getrawbuf_nocheck(bs, (guint8 *)ob, len); | |
| 172 ob[len] = '\0'; | |
| 173 return ob; | |
| 174 } | |
| 175 | |
| 176 int byte_stream_put8(ByteStream *bs, guint8 v) | |
| 177 { | |
| 178 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 1, 0); | |
| 179 | |
| 180 bs->offset += aimutil_put8(bs->data + bs->offset, v); | |
| 181 return 1; | |
| 182 } | |
| 183 | |
| 184 int byte_stream_put16(ByteStream *bs, guint16 v) | |
| 185 { | |
| 186 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 2, 0); | |
| 187 | |
| 188 bs->offset += aimutil_put16(bs->data + bs->offset, v); | |
| 189 return 2; | |
| 190 } | |
| 191 | |
| 192 int byte_stream_put32(ByteStream *bs, guint32 v) | |
| 193 { | |
| 194 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 4, 0); | |
| 195 | |
| 196 bs->offset += aimutil_put32(bs->data + bs->offset, v); | |
| 197 return 1; | |
| 198 } | |
| 199 | |
| 200 int byte_stream_putle8(ByteStream *bs, guint8 v) | |
| 201 { | |
| 202 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 1, 0); | |
| 203 | |
| 204 bs->offset += aimutil_putle8(bs->data + bs->offset, v); | |
| 205 return 1; | |
| 206 } | |
| 207 | |
| 208 int byte_stream_putle16(ByteStream *bs, guint16 v) | |
| 209 { | |
| 210 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 2, 0); | |
| 211 | |
| 212 bs->offset += aimutil_putle16(bs->data + bs->offset, v); | |
| 213 return 2; | |
| 214 } | |
| 215 | |
| 216 int byte_stream_putle32(ByteStream *bs, guint32 v) | |
| 217 { | |
| 218 g_return_val_if_fail(byte_stream_bytes_left(bs) >= 4, 0); | |
| 219 | |
| 220 bs->offset += aimutil_putle32(bs->data + bs->offset, v); | |
| 221 return 1; | |
| 222 } | |
| 223 | |
| 224 | |
| 225 int byte_stream_putraw(ByteStream *bs, const guint8 *v, size_t len) | |
| 226 { | |
| 227 g_return_val_if_fail(byte_stream_bytes_left(bs) >= len, 0); | |
| 228 | |
| 229 memcpy(bs->data + bs->offset, v, len); | |
| 230 bs->offset += len; | |
| 231 return len; | |
| 232 } | |
| 233 | |
| 234 int byte_stream_putstr(ByteStream *bs, const char *str) | |
| 235 { | |
| 236 return byte_stream_putraw(bs, (guint8 *)str, strlen(str)); | |
| 237 } | |
| 238 | |
| 239 int byte_stream_putbs(ByteStream *bs, ByteStream *srcbs, size_t len) | |
| 240 { | |
| 241 g_return_val_if_fail(byte_stream_bytes_left(srcbs) >= len, 0); | |
| 242 g_return_val_if_fail(byte_stream_bytes_left(bs) >= len, 0); | |
| 243 | |
| 244 memcpy(bs->data + bs->offset, srcbs->data + srcbs->offset, len); | |
| 245 bs->offset += len; | |
| 246 srcbs->offset += len; | |
| 247 return len; | |
| 248 } | |
| 249 | |
| 250 int byte_stream_putuid(ByteStream *bs, OscarData *od) | |
| 251 { | |
| 252 PurpleAccount *account; | |
| 253 | |
| 254 account = purple_connection_get_account(od->gc); | |
| 255 | |
| 256 return byte_stream_putle32(bs, atoi(purple_account_get_username(account))); | |
| 257 } | |
| 258 | |
| 259 void byte_stream_put_bart_asset(ByteStream *bs, guint16 type, ByteStream *data) | |
| 260 { | |
| 261 byte_stream_put16(bs, type); | |
| 262 | |
| 263 if (data != NULL && data->len > 0) { | |
| 264 /* Flags. 0x04 means "this asset has data attached to it" */ | |
| 265 byte_stream_put8(bs, 0x04); /* Flags */ | |
| 266 byte_stream_put8(bs, data->len); /* Length */ | |
| 267 byte_stream_rewind(data); | |
| 268 byte_stream_putbs(bs, data, data->len); /* Data */ | |
| 269 } else { | |
| 270 byte_stream_put8(bs, 0x00); /* No flags */ | |
| 271 byte_stream_put8(bs, 0x00); /* Length */ | |
| 272 /* No data */ | |
| 273 } | |
| 274 } | |
| 275 | |
| 276 void byte_stream_put_bart_asset_str(ByteStream *bs, guint16 type, const char *datastr) | |
| 277 { | |
| 278 ByteStream data; | |
| 279 size_t len = datastr != NULL ? strlen(datastr) : 0; | |
| 280 | |
| 281 if (len > 0) { | |
| 282 byte_stream_new(&data, 2 + len + 2); | |
| 283 byte_stream_put16(&data, len); /* Length */ | |
| 284 byte_stream_putstr(&data, datastr); /* String */ | |
| 285 byte_stream_put16(&data, 0x0000); /* Unknown */ | |
| 286 byte_stream_put_bart_asset(bs, type, &data); | |
| 287 byte_stream_destroy(&data); | |
| 288 } else { | |
| 289 byte_stream_put_bart_asset(bs, type, NULL); | |
| 290 } | |
| 291 } |
