Text   |  XML   |  ReML   |   Visible Warnings:

Null Pointer Dereference  at strescape.c:61

No properties have been set. | edit properties
Jump to warning location ↓ warning details...
Show Events | Options

client_handle_input

(/home/sate/Testcases/c/cve/dovecot-1.2.0/src/imap-login/client.c)expand/collapse
Show more  
 298  static bool client_handle_input(struct imap_client *client)
 299  {
 300          const struct imap_arg *args;
 301          const char *msg;
 302          int ret;
 303          bool fatal;
 304   
 305          i_assert(!client->common.authenticating);
 306   
 307          if (client->cmd_finished) {
 308                  /* clear the previous command from memory. don't do this
 309                     immediately after handling command since we need the 
 310                     cmd_tag to stay some time after authentication commands. */
 311                  client->cmd_tag = NULL;
 312                  client->cmd_name = NULL;
 313[+]                 imap_parser_reset(client->parser);
 314   
 315                  /* remove \r\n */
 316                  if (client->skip_line) {
 317                          if (!client_skip_line(client))
 318                                  return FALSE;
 319                          client->skip_line = FALSE;
 320                  }
 321   
 322                  client->cmd_finished = FALSE;
 323          }
 324   
 325          if (client->cmd_tag == NULL) {
 326                  client->cmd_tag = imap_parser_read_word(client->parser);
 327                  if (client->cmd_tag == NULL)
 328                          return FALSE; /* need more data */
 329          }
 330   
 331          if (client->cmd_name == NULL) {
 332                  client->cmd_name = imap_parser_read_word(client->parser);
 333                  if (client->cmd_name == NULL)
 334                          return FALSE; /* need more data */
 335          }
 336   
 337[+]         switch (imap_parser_read_args(client->parser, 0, 0, &args)) {
expand/collapse

imap_parser_read_args

(/home/sate/Testcases/c/cve/dovecot-1.2.0/src/lib-imap/imap-parser.c)expand/collapse
Show more  
 567  int imap_parser_read_args(struct imap_parser *parser, unsigned int count,
 568                            enum imap_parser_flags flags,
 569                            const struct imap_arg **args_r)
 570  {
 571          parser->flags = flags;
 572   
 573          if (parser->literal_size_return) {
 574                  /* delete EOL */
 575                  array_delete(&parser->root_list,
 576                               array_count(&parser->root_list)-1, 1);
 577                  parser->literal_size_return = FALSE;
 578          }
 579   
 580          while (!parser->eol && (count == 0 || IS_UNFINISHED(parser) ||
 581                                  array_count(&parser->root_list) < count)) {
 582[+]                 if (!imap_parser_read_arg(parser))
expand/collapse

imap_parser_read_arg

(/home/sate/Testcases/c/cve/dovecot-1.2.0/src/lib-imap/imap-parser.c)expand/collapse
Show more  
 439  static int imap_parser_read_arg(struct imap_parser *parser)
 440  {
 441          const unsigned char *data;
 442          size_t data_size;
 443   
 444[+]         data = i_stream_get_data(parser->input, &data_size);
 445          if (data_size == 0)
 446                  return FALSE;
 447   
 448          while (parser->cur_type == ARG_PARSE_NONE) {
 449                  /* we haven't started parsing yet */
 450                  if (!imap_parser_skip_to_next(parser, &data, &data_size))
 451                          return FALSE;
 452                  i_assert(parser->cur_pos == 0);
 453   
 454                  switch (data[0]) {
 455                  case '\r':
 456                          if (data_size == 1) {
 457                                  /* wait for LF */
 458                                  return FALSE;
 459                          }
 460                          if (data[1] != '\n') {
 461                                  parser->error = "CR sent without LF";
 462                                  return FALSE;
 463                          }
 464                          /* fall through */
 465                  case '\n':
 466                          /* unexpected end of line */
 467                          parser->eol = TRUE;
 468                          return FALSE;
 469                  case '"':
 470                          parser->cur_type = ARG_PARSE_STRING;
 471                          parser->str_first_escape = -1;
 472                          break;
 473                  case '{':
 474                          parser->cur_type = ARG_PARSE_LITERAL;
 475                          parser->literal_size = 0;
 476                          parser->literal_nonsync = FALSE;
 477                          break;
 478                  case '(':
 479                          imap_parser_open_list(parser);
 480                          break;
 481                  case ')':
 482                          if (!imap_parser_close_list(parser))
 483                                  return FALSE;
 484   
 485                          if (parser->list_arg == NULL) {
 486                                  /* end of argument */
 487                                  parser->cur_pos++;
 488                                  return TRUE;
 489                          }
 490                          break;
 491                  default:
 492                          if (!is_valid_atom_char(parser, data[0]))
 493                                  return FALSE;
 494                          parser->cur_type = ARG_PARSE_ATOM;
 495                          break;
 496                  }
 497   
 498                  parser->cur_pos++;
 499          }
 500   
 501          i_assert(data_size > 0);
 502   
 503          switch (parser->cur_type) {
 504          case ARG_PARSE_ATOM:
 505                  if (!imap_parser_read_atom(parser, data, data_size))
 506                          return FALSE;
 507                  break;
 508          case ARG_PARSE_STRING:
 509                  if (!imap_parser_read_string(parser, data, data_size))
 510                          return FALSE;
 511                  break;
 512          case ARG_PARSE_LITERAL:
 513                  if (!imap_parser_read_literal(parser, data, data_size))
 514                          return FALSE;
 515   
 516                  /* pass through to parsing data. since input->skip was 
 517                     modified, we need to get the data start position again. */
 518[+]                 data = i_stream_get_data(parser->input, &data_size);
 519   
 520                  /* fall through */
 521          case ARG_PARSE_LITERAL_DATA:
 522          case ARG_PARSE_LITERAL_DATA_FORCED:
 523[+]                 if (!imap_parser_read_literal_data(parser, data, data_size))
expand/collapse

imap_parser_read_literal_data

(/home/sate/Testcases/c/cve/dovecot-1.2.0/src/lib-imap/imap-parser.c)expand/collapse
Show more  
 386  static int imap_parser_read_literal_data(struct imap_parser *parser,
 387                                           const unsigned char *data,
 388                                           size_t data_size)
 389  {
 390          if (parser->literal_skip_crlf) {
 391                  /* skip \r\n or \n, anything else gives an error */
 392                  if (data_size == 0)
 393                          return FALSE;
 394   
 395                  if (*data == '\r') {
 396                          parser->line_size++;
 397                          data++; data_size--;
 398                          i_stream_skip(parser->input, 1);
 399   
 400                          if (data_size == 0)
 401                                  return FALSE;
 402                  }
 403   
 404                  if (*data != '\n') {
 405                          parser->error = "Missing LF after literal size";
 406                          return FALSE;
 407                  }
 408   
 409                  parser->line_size++;
 410                  data++; data_size--;
 411                  i_stream_skip(parser->input, 1);
 412   
 413                  parser->literal_skip_crlf = FALSE;
 414   
 415                  i_assert(parser->cur_pos == 0);
 416          }
 417   
 418          if ((parser->flags & IMAP_PARSE_FLAG_LITERAL_SIZE) == 0 ||
 419              parser->cur_type == ARG_PARSE_LITERAL_DATA_FORCED) {
 420                  /* now we just wait until we've read enough data */
 421                  if (data_size < parser->literal_size)
 422                          return FALSE;
 423                  else {
 424                          imap_parser_save_arg(parser, data,
 425[+]                                              (size_t)parser->literal_size);
expand/collapse

imap_parser_save_arg

(/home/sate/Testcases/c/cve/dovecot-1.2.0/src/lib-imap/imap-parser.c)expand/collapse
Show more  
 171  static void imap_parser_save_arg(struct imap_parser *parser,
 172                                   const unsigned char *data, size_t size)
 173  {
 174          struct imap_arg *arg;
 175          char *str;
 176   
 177          arg = imap_arg_create(parser);
 178   
 179          switch (parser->cur_type) {
 180          case ARG_PARSE_ATOM:
 181                  if (size == 3 && memcmp(data, "NIL", 3) == 0) {
 182                          /* NIL argument */
 183                          arg->type = IMAP_ARG_NIL;
 184                  } else {
 185                          /* simply save the string */
 186                          arg->type = IMAP_ARG_ATOM;
 187                          arg->_data.str = p_strndup(parser->pool, data, size);
 188                  }
 189                  break;
 190          case ARG_PARSE_STRING:
 191                  /* data is quoted and may contain escapes. */
 192                  i_assert(size > 0);
 193   
 194                  arg->type = IMAP_ARG_STRING;
 195[+]                 str = p_strndup(parser->pool, data+1, size-1);
 196   
 197                  /* remove the escapes */
 198                  if (parser->str_first_escape >= 0 &&
 199                      (parser->flags & IMAP_PARSE_FLAG_NO_UNESCAPE) == 0) {
 200                          /* -1 because we skipped the '"' prefix */
 201[+]                         str_unescape(str + parser->str_first_escape-1);
expand/collapse

str_unescape

(/home/sate/Testcases/c/cve/dovecot-1.2.0/src/lib/strescape.c)expand/collapse
Show more  
 56  char *str_unescape(char *str)
 57  {
 58          /* @UNSAFE */
 59          char *dest, *start = str;
 60   
 61          while (*str != '\\') {
Show more  
Show more  
Show more  
Show more  
Show more  
Show more  




Change Warning 11775.25847 : Null Pointer Dereference

Priority:
State:
Finding:
Owner:
Note: