#include "wsint.h"Include dependency graph for wsencode.c:
Go to the source code of this file.
Defines | |
| #define | WS_MB_CONT_BIT 0x80 |
| #define | WS_MB_DATA_MASK 0x7f |
Functions | |
| unsigned char * | ws_encode_mb_uint32 (WsUInt32 value, unsigned char *buffer, size_t *len_return) |
| WsUInt32 | ws_decode_mb_uint32 (const unsigned char *buffer, size_t *len) |
| WsBool | ws_encode_buffer (WsBuffer *buffer,...) |
| size_t | ws_decode_buffer (const unsigned char *buffer, size_t buffer_len,...) |
|
|
Definition at line 74 of file wsencode.c. |
|
|
Definition at line 75 of file wsencode.c. |
|
||||||||||||||||
|
Definition at line 222 of file wsencode.c. References ws_decode_mb_uint32(), WS_ENC_BYTE, WS_ENC_DATA, WS_ENC_INT16, WS_ENC_INT32, WS_ENC_INT8, WS_ENC_MB_UINT16, WS_ENC_MB_UINT32, WS_ENC_UINT16, WS_ENC_UINT32, WS_ENC_UINT8, ws_fatal(), WS_GET_UINT16, WS_GET_UINT32, WS_GET_UINT8, WsEncodingSpec, WsUInt16, WsUInt32, and WsUInt8. Referenced by ws_bc_decode(). 00223 {
00224 va_list ap;
00225 WsEncodingSpec spec;
00226 WsUInt8 *i8p;
00227 WsUInt16 *i16p;
00228 WsUInt32 *i32p;
00229 unsigned char **cpp;
00230 size_t len;
00231 size_t orig_buffer_len = buffer_len;
00232
00233 va_start(ap, buffer_len);
00234
00235 while ((spec = va_arg(ap, int)) != WS_ENC_END) {
00236 switch (spec) {
00237 case WS_ENC_BYTE:
00238 case WS_ENC_INT8:
00239 case WS_ENC_UINT8:
00240 if (buffer_len < 1)
00241 goto too_short_buffer;
00242
00243 i8p = va_arg(ap, WsUInt8 *);
00244 WS_GET_UINT8(buffer, *i8p);
00245
00246 buffer++;
00247 buffer_len--;
00248 break;
00249
00250 case WS_ENC_INT16:
00251 case WS_ENC_UINT16:
00252 if (buffer_len < 2)
00253 goto too_short_buffer;
00254
00255 i16p = va_arg(ap, WsUInt16 *);
00256 WS_GET_UINT16(buffer, *i16p);
00257
00258 buffer += 2;
00259 buffer_len -= 2;
00260 break;
00261
00262 case WS_ENC_INT32:
00263 case WS_ENC_UINT32:
00264 if (buffer_len < 4)
00265 goto too_short_buffer;
00266
00267 i32p = va_arg(ap, WsUInt32 *);
00268 WS_GET_UINT32(buffer, *i32p);
00269
00270 buffer += 4;
00271 buffer_len -= 4;
00272 break;
00273
00274 case WS_ENC_MB_UINT16:
00275 case WS_ENC_MB_UINT32:
00276 {
00277 size_t len = buffer_len;
00278 WsUInt32 i32;
00279
00280 if (buffer_len < 1)
00281 goto too_short_buffer;
00282
00283 i32 = ws_decode_mb_uint32(buffer, &len);
00284
00285 if (spec == WS_ENC_MB_UINT16) {
00286 i16p = va_arg(ap, WsUInt16 *);
00287 *i16p = i32;
00288 } else {
00289 i32p = va_arg(ap, WsUInt32 *);
00290 *i32p = i32;
00291 }
00292
00293 buffer += len;
00294 buffer_len -= len;
00295 }
00296 break;
00297
00298 case WS_ENC_DATA:
00299 cpp = va_arg(ap, unsigned char **);
00300 len = va_arg(ap, size_t);
00301
00302 if (buffer_len < len)
00303 goto too_short_buffer;
00304
00305 *cpp = (unsigned char *) buffer;
00306 buffer += len;
00307 buffer_len -= len;
00308 break;
00309
00310 default:
00311 ws_fatal("ws_encode_buffer(): unknown type %d: probably a missing "
00312 "WS_ENC_END",
00313 spec);
00314 break;
00315 }
00316 }
00317 va_end(ap);
00318
00319 return orig_buffer_len - buffer_len;
00320
00321 too_short_buffer:
00322
00323 va_end(ap);
00324
00325 return 0;
00326 }
|
Here is the call graph for this function:
|
||||||||||||
|
Definition at line 104 of file wsencode.c. References WsUInt32. Referenced by ws_bc_data_free(), and ws_decode_buffer(). 00105 {
00106 WsUInt32 value = 0;
00107 size_t i;
00108
00109 for (i = 0; i < *len; i++) {
00110 value <<= 7;
00111 value |= buffer[i] & WS_MB_DATA_MASK;
00112
00113 if ((buffer[i] & WS_MB_CONT_BIT) == 0)
00114 break;
00115 }
00116
00117 *len = i + 1;
00118
00119 return value;
00120 }
|
|
||||||||||||
|
Definition at line 123 of file wsencode.c. References data, error(), ws_buffer_append_space(), WS_ENC_BYTE, WS_ENC_DATA, WS_ENC_INT16, WS_ENC_INT32, WS_ENC_INT8, WS_ENC_MB_UINT16, WS_ENC_MB_UINT32, WS_ENC_UINT16, WS_ENC_UINT32, WS_ENC_UINT8, ws_encode_mb_uint32(), ws_fatal(), WS_PUT_UINT16, WS_PUT_UINT32, WS_PUT_UINT8, WsBool, WsBuffer, WsEncodingSpec, and WsUInt32. Referenced by ws_bc_encode(). 00124 {
00125 va_list ap;
00126 WsEncodingSpec spec;
00127 int ival;
00128 unsigned char *p;
00129 unsigned char *cp;
00130 size_t len;
00131 WsUInt32 ui32;
00132 unsigned char data[64];
00133
00134 va_start(ap, buffer);
00135
00136 while ((spec = va_arg(ap, int)) != WS_ENC_END)
00137 {
00138 switch (spec)
00139 {
00140 case WS_ENC_BYTE:
00141 case WS_ENC_INT8:
00142 case WS_ENC_UINT8:
00143 ival = va_arg(ap, int);
00144
00145 if (!ws_buffer_append_space(buffer, &p, 1))
00146 goto error;
00147
00148 WS_PUT_UINT8(p, ival);
00149 break;
00150
00151 case WS_ENC_INT16:
00152 case WS_ENC_UINT16:
00153 ival = va_arg(ap, int);
00154
00155 if (!ws_buffer_append_space(buffer, &p, 2))
00156 goto error;
00157
00158 WS_PUT_UINT16(p, ival);
00159 break;
00160
00161 case WS_ENC_INT32:
00162 case WS_ENC_UINT32:
00163 ival = va_arg(ap, long);
00164
00165 if (!ws_buffer_append_space(buffer, &p, 4))
00166 goto error;
00167
00168 WS_PUT_UINT32(p, ival);
00169 break;
00170
00171 case WS_ENC_MB_UINT16:
00172 case WS_ENC_MB_UINT32:
00173 if (spec == WS_ENC_MB_UINT16)
00174 ui32 = va_arg(ap, int);
00175 else
00176 ui32 = va_arg(ap, long);
00177
00178 len = sizeof(data);
00179 cp = ws_encode_mb_uint32(ui32, data, &len);
00180
00181 if (!ws_buffer_append_space(buffer, &p, len))
00182 goto error;
00183
00184 memcpy(p, cp, len);
00185 break;
00186
00187 case WS_ENC_DATA:
00188 cp = va_arg(ap, unsigned char *);
00189 len = va_arg(ap, unsigned int);
00190
00191 if (!ws_buffer_append_space(buffer, &p, len))
00192 goto error;
00193
00194 memcpy(p, cp, len);
00195 break;
00196
00197 default:
00198 ws_fatal("ws_encode_buffer(): unknown type %d: probably a missing "
00199 "WS_ENC_END",
00200 spec);
00201 break;
00202 }
00203 }
00204
00205 va_end(ap);
00206
00207 return WS_TRUE;
00208
00209
00210 /*
00211 * Error handling.
00212 */
00213
00214 error:
00215
00216 va_end(ap);
00217
00218 return WS_FALSE;
00219 }
|
Here is the call graph for this function:
|
||||||||||||||||
|
Definition at line 79 of file wsencode.c. Referenced by ws_bc_encode(), and ws_encode_buffer(). 00081 {
00082 unsigned char *p = buffer + WS_MB_UINT32_MAX_ENCODED_LEN;
00083 size_t len = 1;
00084
00085 /* Set the terminator byte. */
00086 *p = value & WS_MB_DATA_MASK;
00087 value >>= 7;
00088 p--;
00089
00090 /* And add the data. */
00091 while (value > 0) {
00092 *p = (value & WS_MB_DATA_MASK) | WS_MB_CONT_BIT;
00093 value >>= 7;
00094 p--;
00095 len++;
00096 }
00097
00098 *len_return = len;
00099
00100 return p + 1;
00101 }
|