lib/silccore/silcargument.c

   1 /*
   2
   3   silcargument.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2001 - 2006 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19 /* Implementation of Argument Payload routines */
  20 /* $Id$ */
  21
  22 #include "silc.h"
  23 #include "silcargument.h"
  24
  25 /******************************************************************************
  26
  27                              Argument Payload
  28
  29 ******************************************************************************/
  30
  31 struct SilcArgumentPayloadStruct {
  32   SilcUInt32 argc;
  33   unsigned char **argv;
  34   SilcUInt32 *argv_lens;
  35   SilcUInt32 *argv_types;
  36   SilcUInt32 pos;
  37 };
  38
  39 /* Parses arguments and returns them into Argument Payload structure. */
  40
  41 SilcArgumentPayload silc_argument_payload_parse(const unsigned char *payload,
  42                                                 SilcUInt32 payload_len,
  43                                                 SilcUInt32 argc)
  44 {
  45   SilcBufferStruct buffer;
  46   SilcArgumentPayload newp;
  47   SilcUInt16 p_len = 0;
  48   unsigned char arg_num = 0;
  49   unsigned char arg_type = 0;
  50   SilcUInt32 pull_len = 0;
  51   int i = 0, ret;
  52
  53   silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
  54   newp = silc_calloc(1, sizeof(*newp));
  55   if (!newp)
  56     return NULL;
  57   newp->argv = silc_calloc(argc, sizeof(unsigned char *));
  58   if (!newp->argv)
  59     goto err;
  60   newp->argv_lens = silc_calloc(argc, sizeof(SilcUInt32));
  61   if (!newp->argv_lens)
  62     goto err;
  63   newp->argv_types = silc_calloc(argc, sizeof(SilcUInt32));
  64   if (!newp->argv_types)
  65     goto err;
  66
  67   /* Get arguments */
  68   arg_num = 1;
  69   for (i = 0; i < argc; i++) {
  70     ret = silc_buffer_unformat(&buffer,
  71                                SILC_STR_UI_SHORT(&p_len),
  72                                SILC_STR_UI_CHAR(&arg_type),
  73                                SILC_STR_END);
  74     if (ret == -1 || p_len > silc_buffer_len(&buffer) - 3)
  75       goto err;
  76
  77     newp->argv_lens[i] = p_len;
  78     newp->argv_types[i] = arg_type;
  79
  80     /* Get argument data */
  81     silc_buffer_pull(&buffer, 3);
  82     ret = silc_buffer_unformat(&buffer,
  83                                SILC_STR_UI_XNSTRING_ALLOC(&newp->argv[i],
  84                                                           p_len),
  85                                SILC_STR_END);
  86     if (ret == -1)
  87       goto err;
  88
  89     silc_buffer_pull(&buffer, p_len);
  90     pull_len += 3 + p_len;
  91   }
  92
  93   if (silc_buffer_len(&buffer) != 0) {
  94     SILC_LOG_DEBUG(("Malformed argument payload"));
  95     goto err;
  96   }
  97
  98   newp->argc = argc;
  99   newp->pos = 0;
 100
 101   silc_buffer_push(&buffer, pull_len);
 102
 103   return newp;
 104
 105  err:
 106   SILC_LOG_DEBUG(("Error parsing argument payload"));
 107   if (i)
 108     for (ret = 0; ret < i; ret++)
 109       silc_free(newp->argv[ret]);
 110
 111   silc_free(newp->argv);
 112   silc_free(newp->argv_lens);
 113   silc_free(newp->argv_types);
 114   silc_free(newp);
 115
 116   return NULL;
 117 }
 118
 119 /* Encodes arguments in to Argument Paylods returning them to SilcBuffer. */
 120
 121 SilcBuffer silc_argument_payload_encode(SilcUInt32 argc,
 122                                         unsigned char **argv,
 123                                         SilcUInt32 *argv_lens,
 124                                         SilcUInt32 *argv_types)
 125 {
 126   SilcBuffer buffer;
 127   SilcUInt32 len;
 128   int i;
 129
 130   len = 0;
 131   for (i = 0; i < argc; i++)
 132     len += 3 + (SilcUInt16)argv_lens[i];
 133
 134   buffer = silc_buffer_alloc_size(len);
 135   if (!buffer)
 136     return NULL;
 137
 138   /* Put arguments */
 139   for (i = 0; i < argc; i++) {
 140     silc_buffer_format(buffer,
 141                        SILC_STR_UI_SHORT(argv_lens[i]),
 142                        SILC_STR_UI_CHAR(argv_types[i]),
 143                        SILC_STR_UI_XNSTRING(argv[i], (SilcUInt16)argv_lens[i]),
 144                        SILC_STR_END);
 145     silc_buffer_pull(buffer, 3 + (SilcUInt16)argv_lens[i]);
 146   }
 147
 148   silc_buffer_push(buffer, len);
 149
 150   return buffer;
 151 }
 152
 153 /* Encode one argument to buffer */
 154
 155 SilcBuffer silc_argument_payload_encode_one(SilcBuffer args,
 156                                             unsigned char *arg,
 157                                             SilcUInt32 arg_len,
 158                                             SilcUInt32 arg_type)
 159 {
 160   SilcBuffer buffer = args;
 161   SilcUInt32 len;
 162
 163   len = 3 + (SilcUInt16)arg_len;
 164   buffer = silc_buffer_realloc(buffer,
 165                                (buffer ? silc_buffer_truelen(buffer) +
 166                                 len : len));
 167   if (!buffer)
 168     return NULL;
 169   silc_buffer_pull(buffer, silc_buffer_len(buffer));
 170   silc_buffer_pull_tail(buffer, len);
 171   silc_buffer_format(buffer,
 172                      SILC_STR_UI_SHORT(arg_len),
 173                      SILC_STR_UI_CHAR(arg_type),
 174                      SILC_STR_UI_XNSTRING(arg, (SilcUInt16)arg_len),
 175                      SILC_STR_END);
 176   silc_buffer_push(buffer, buffer->data - buffer->head);
 177
 178   return buffer;
 179 }
 180
 181 /* Same as above but encode the buffer from SilcArgumentPayload structure
 182    instead of raw data. */
 183
 184 SilcBuffer silc_argument_payload_encode_payload(SilcArgumentPayload payload)
 185 {
 186   SilcBuffer buffer;
 187   SilcUInt32 len;
 188   int i;
 189
 190   len = 0;
 191   for (i = 0; i < payload->argc; i++)
 192     len += 3 + payload->argv_lens[i];
 193
 194   buffer = silc_buffer_alloc_size(len);
 195   if (!buffer)
 196     return NULL;
 197
 198   /* Put arguments */
 199   for (i = 0; i < payload->argc; i++) {
 200     silc_buffer_format(buffer,
 201                        SILC_STR_UI_SHORT(payload->argv_lens[i]),
 202                        SILC_STR_UI_CHAR(payload->argv_types[i]),
 203                        SILC_STR_UI_XNSTRING(payload->argv[i],
 204                                             payload->argv_lens[i]),
 205                        SILC_STR_END);
 206     silc_buffer_pull(buffer, 3 + payload->argv_lens[i]);
 207   }
 208
 209   silc_buffer_push(buffer, len);
 210
 211   return buffer;
 212 }
 213
 214 /* Frees Argument Payload */
 215
 216 void silc_argument_payload_free(SilcArgumentPayload payload)
 217 {
 218   int i;
 219
 220   if (payload) {
 221     for (i = 0; i < payload->argc; i++)
 222       silc_free(payload->argv[i]);
 223
 224     silc_free(payload->argv);
 225     silc_free(payload->argv_lens);
 226     silc_free(payload->argv_types);
 227     silc_free(payload);
 228   }
 229 }
 230
 231 /* Returns number of arguments in payload */
 232
 233 SilcUInt32 silc_argument_get_arg_num(SilcArgumentPayload payload)
 234 {
 235   return payload ? payload->argc : 0;
 236 }
 237
 238 /* Returns first argument from payload. */
 239
 240 unsigned char *silc_argument_get_first_arg(SilcArgumentPayload payload,
 241                                            SilcUInt32 *type,
 242                                            SilcUInt32 *ret_len)
 243 {
 244   if (!payload)
 245     return NULL;
 246
 247   payload->pos = 0;
 248
 249   if (type)
 250     *type = payload->argv_types[payload->pos];
 251   if (ret_len)
 252     *ret_len = payload->argv_lens[payload->pos];
 253
 254   return payload->argv[payload->pos++];
 255 }
 256
 257 /* Returns next argument from payload or NULL if no more arguments. */
 258
 259 unsigned char *silc_argument_get_next_arg(SilcArgumentPayload payload,
 260                                           SilcUInt32 *type,
 261                                           SilcUInt32 *ret_len)
 262 {
 263   if (!payload)
 264     return NULL;
 265
 266   if (payload->pos >= payload->argc)
 267     return NULL;
 268
 269   if (type)
 270     *type = payload->argv_types[payload->pos];
 271   if (ret_len)
 272     *ret_len = payload->argv_lens[payload->pos];
 273
 274   return payload->argv[payload->pos++];
 275 }
 276
 277 /* Returns argument which type is `type'. */
 278
 279 unsigned char *silc_argument_get_arg_type(SilcArgumentPayload payload,
 280                                           SilcUInt32 type,
 281                                           SilcUInt32 *ret_len)
 282 {
 283   int i;
 284
 285   if (!payload)
 286     return NULL;
 287
 288   for (i = 0; i < payload->argc; i++)
 289     if (payload->argv_types[i] == type)
 290       break;
 291
 292   if (i >= payload->argc)
 293     return NULL;
 294
 295   if (ret_len)
 296     *ret_len = payload->argv_lens[i];
 297
 298   return payload->argv[i];
 299 }
 300
 301 /* Return argument already decoded */
 302
 303 SilcBool silc_argument_get_decoded(SilcArgumentPayload payload,
 304                                    SilcUInt32 type,
 305                                    SilcArgumentDecodeType dec_type,
 306                                    void *ret_arg,
 307                                    void **ret_arg_alloc)
 308 {
 309   unsigned char *tmp;
 310   SilcUInt32 tmp_len;
 311
 312   tmp = silc_argument_get_arg_type(payload, type, &tmp_len);
 313   if (!tmp)
 314     return FALSE;
 315
 316   switch (dec_type) {
 317
 318   case SILC_ARGUMENT_ID:
 319     if (ret_arg)
 320       if (!silc_id_payload_parse_id(tmp, tmp_len, (SilcID *)ret_arg))
 321         return FALSE;
 322
 323     if (ret_arg_alloc) {
 324       SilcID id;
 325       if (!silc_id_payload_parse_id(tmp, tmp_len, &id))
 326         return FALSE;
 327       *ret_arg_alloc = silc_memdup(&id, sizeof(id));
 328     }
 329     break;
 330
 331   case SILC_ARGUMENT_PUBLIC_KEY:
 332     {
 333       SilcPublicKey public_key;
 334
 335       if (!ret_arg_alloc)
 336         return FALSE;
 337
 338       if (!silc_public_key_payload_decode(tmp, tmp_len, &public_key))
 339         return FALSE;
 340
 341       *ret_arg_alloc = public_key;
 342     }
 343     break;
 344
 345   case SILC_ARGUMENT_ATTRIBUTES:
 346     if (!ret_arg_alloc)
 347       return FALSE;
 348
 349     *ret_arg_alloc = silc_attribute_payload_parse(tmp, tmp_len);
 350     break;
 351
 352   case SILC_ARGUMENT_UINT32:
 353     if (tmp_len != 4)
 354       return FALSE;
 355
 356     if (ret_arg) {
 357       SilcUInt32 *i = ret_arg;
 358       SILC_GET32_MSB(*i, tmp);
 359     }
 360
 361     if (ret_arg_alloc) {
 362       SilcUInt32 i;
 363       SILC_GET32_MSB(i, tmp);
 364       *ret_arg_alloc = silc_memdup(&i, sizeof(i));
 365     }
 366     break;
 367
 368   case SILC_ARGUMENT_BOOL:
 369     if (tmp_len != 1)
 370       return FALSE;
 371
 372     if (ret_arg) {
 373       SilcBool *b = ret_arg;
 374       *b = (tmp[0] == 0x01 ? TRUE : FALSE);
 375     }
 376
 377     if (ret_arg_alloc) {
 378       SilcBool b;
 379       b = (tmp[0] == 0x01 ? TRUE : FALSE);
 380       *ret_arg_alloc = silc_memdup(&b, sizeof(b));
 381     }
 382     break;
 383
 384   default:
 385     return FALSE;
 386   }
 387
 388   return TRUE;
 389 }