← Back to branch summary

~brianaker/gearmand/734663

« back to all changes in this revision

Viewing changes to libgearman-server/server.c

  • Committer: Brian Aker
  • Date: 2011-02-15 01:48:22 UTC
  • mfrom: (373.1.5 gearmand-trunk)
  • Revision ID: brian@tangent.org-20110215014822-2rbjyk2a1stv4pev
Merge in bug fix for memcached, and various icc failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgearman-server/server.c
310
310
    break;
311
311
 
312
312
  case GEARMAN_COMMAND_GET_STATUS:
313
 
    /* This may not be NULL terminated, so copy to make sure it is. */
314
 
    snprintf(job_handle, GEARMAN_JOB_HANDLE_SIZE, "%.*s",
315
 
             (uint32_t)(packet->arg_size[0]), (char *)(packet->arg[0]));
316
 
 
317
 
    server_job= gearman_server_job_get(server_con->thread->server, job_handle, NULL);
318
 
 
319
 
    /* Queue status result packet. */
320
 
    if (server_job == NULL)
321
 
    {
322
 
      ret= gearman_server_io_packet_add(server_con, false,
323
 
                                        GEARMAN_MAGIC_RESPONSE,
324
 
                                        GEARMAN_COMMAND_STATUS_RES, job_handle,
325
 
                                        (size_t)(strlen(job_handle) + 1),
326
 
                                        "0", (size_t)2, "0", (size_t)2, "0",
327
 
                                        (size_t)2, "0", (size_t)1, NULL);
328
 
    }
329
 
    else
330
 
    {
331
 
      snprintf(numerator_buffer, 11, "%u", server_job->numerator);
332
 
      snprintf(denominator_buffer, 11, "%u", server_job->denominator);
333
 
 
334
 
      ret= gearman_server_io_packet_add(server_con, false,
335
 
                                        GEARMAN_MAGIC_RESPONSE,
336
 
                                        GEARMAN_COMMAND_STATUS_RES, job_handle,
337
 
                                        (size_t)(strlen(job_handle) + 1),
338
 
                                        "1", (size_t)2,
339
 
                                        server_job->worker == NULL ? "0" : "1",
340
 
                                        (size_t)2, numerator_buffer,
341
 
                                        (size_t)(strlen(numerator_buffer) + 1),
342
 
                                        denominator_buffer,
343
 
                                        (size_t)strlen(denominator_buffer),
344
 
                                        NULL);
345
 
    }
346
 
 
347
 
    if (ret != GEARMAN_SUCCESS)
348
 
      return ret;
 
313
    {
 
314
      int check_length;
 
315
      /* This may not be NULL terminated, so copy to make sure it is. */
 
316
      check_length= snprintf(job_handle, GEARMAN_JOB_HANDLE_SIZE, "%.*s",
 
317
                             (int)(packet->arg_size[0]), (char *)(packet->arg[0]));
 
318
 
 
319
      if (check_length >= GEARMAN_JOB_HANDLE_SIZE || GEARMAN_JOB_HANDLE_SIZE < 0)
 
320
        return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
321
 
 
322
      server_job= gearman_server_job_get(server_con->thread->server, job_handle, NULL);
 
323
 
 
324
      /* Queue status result packet. */
 
325
      if (server_job == NULL)
 
326
      {
 
327
        ret= gearman_server_io_packet_add(server_con, false,
 
328
                                          GEARMAN_MAGIC_RESPONSE,
 
329
                                          GEARMAN_COMMAND_STATUS_RES, job_handle,
 
330
                                          (size_t)(strlen(job_handle) + 1),
 
331
                                          "0", (size_t)2, "0", (size_t)2, "0",
 
332
                                          (size_t)2, "0", (size_t)1, NULL);
 
333
      }
 
334
      else
 
335
      {
 
336
        check_length= snprintf(numerator_buffer, sizeof(numerator_buffer), "%u", server_job->numerator);
 
337
        if ((size_t)check_length >= sizeof(numerator_buffer) || sizeof(numerator_buffer) < 0)
 
338
          return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
339
 
 
340
        check_length= snprintf(denominator_buffer, sizeof(denominator_buffer), "%u", server_job->denominator);
 
341
        if ((size_t)check_length >= sizeof(denominator_buffer) || sizeof(denominator_buffer) < 0)
 
342
          return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
343
 
 
344
        ret= gearman_server_io_packet_add(server_con, false,
 
345
                                          GEARMAN_MAGIC_RESPONSE,
 
346
                                          GEARMAN_COMMAND_STATUS_RES, job_handle,
 
347
                                          (size_t)(strlen(job_handle) + 1),
 
348
                                          "1", (size_t)2,
 
349
                                          server_job->worker == NULL ? "0" : "1",
 
350
                                          (size_t)2, numerator_buffer,
 
351
                                          (size_t)(strlen(numerator_buffer) + 1),
 
352
                                          denominator_buffer,
 
353
                                          (size_t)strlen(denominator_buffer),
 
354
                                          NULL);
 
355
      }
 
356
 
 
357
      if (ret != GEARMAN_SUCCESS)
 
358
        return ret;
 
359
    }
349
360
 
350
361
    break;
351
362
 
352
363
  case GEARMAN_COMMAND_OPTION_REQ:
353
364
    /* This may not be NULL terminated, so copy to make sure it is. */
354
365
    snprintf(option, GEARMAN_OPTION_SIZE, "%.*s",
355
 
             (uint32_t)(packet->arg_size[0]), (char *)(packet->arg[0]));
 
366
             (int)(packet->arg_size[0]), (char *)(packet->arg[0]));
356
367
 
357
368
    if (!strcasecmp(option, "exceptions"))
358
369
    {
506
517
    server_job->numerator= (uint32_t)atoi((char *)(packet->arg[1]));
507
518
 
508
519
    /* This may not be NULL terminated, so copy to make sure it is. */
509
 
    snprintf(denominator_buffer, 11, "%.*s", (uint32_t)(packet->arg_size[2]),
 
520
    snprintf(denominator_buffer, 11, "%.*s", (int)(packet->arg_size[2]),
510
521
             (char *)(packet->arg[2]));
511
522
    server_job->denominator= (uint32_t)atoi(denominator_buffer);
512
523
 
579
590
  case GEARMAN_COMMAND_WORK_FAIL:
580
591
    /* This may not be NULL terminated, so copy to make sure it is. */
581
592
    snprintf(job_handle, GEARMAN_JOB_HANDLE_SIZE, "%.*s",
582
 
             (uint32_t)(packet->arg_size[0]), (char *)(packet->arg[0]));
 
593
             (int)(packet->arg_size[0]), (char *)(packet->arg[0]));
583
594
 
584
595
    server_job= gearman_server_job_get(server_con->thread->server, job_handle,
585
596
                                       server_con);
911
922
    }
912
923
  }
913
924
  else if (!strcasecmp("version", (char *)(packet->arg[0])))
 
925
  {
914
926
    snprintf(data, GEARMAN_TEXT_RESPONSE_SIZE, "%s\n", PACKAGE_VERSION);
 
927
  }
915
928
  else
916
929
  {
917
930
    snprintf(data, GEARMAN_TEXT_RESPONSE_SIZE,