Additional cleanup

libgearman/add.cc

@@ -130,7 +130,7 @@ gearman_task_st *add_task(gearman_client_st *client,
     args[3]= gearman_c_str(workload);
     args_size[3]= gearman_size(workload);
 
-    rc= gearman_packet_create_args(client->universal, &(task->send),
+    rc= gearman_packet_create_args(client->universal, task->send,
                                    GEARMAN_MAGIC_REQUEST, command,
                                    args, args_size,
                                    4);
@@ -140,7 +140,7 @@ gearman_task_st *add_task(gearman_client_st *client,
     args[2]= gearman_c_str(workload);
     args_size[2]= gearman_size(workload);
 
-    rc= gearman_packet_create_args(client->universal, &(task->send),
+    rc= gearman_packet_create_args(client->universal, task->send,
                                    GEARMAN_MAGIC_REQUEST, command,
                                    args, args_size,
                                    3);
@@ -249,7 +249,7 @@ gearman_task_st *add_task(gearman_client_st *client,
   args_size[4]= gearman_size(workload);
 
   gearman_return_t rc;
-  rc= gearman_packet_create_args(client->universal, &(task->send),
+  rc= gearman_packet_create_args(client->universal, task->send,
                                  GEARMAN_MAGIC_REQUEST, command,
                                  args, args_size,
                                  5);

libgearman/client.cc

@@ -976,7 +976,7 @@ gearman_task_st *gearman_client_add_task_status(gearman_client_st *client,
 
   args[0]= job_handle;
   args_size[0]= strlen(job_handle);
-  gearman_return_t rc= gearman_packet_create_args(client->universal, &(task->send),
+  gearman_return_t rc= gearman_packet_create_args(client->universal, task->send,
                                                   GEARMAN_MAGIC_REQUEST,
                                                   GEARMAN_COMMAND_GET_STATUS,
                                                   args, args_size, 1);
@@ -1414,7 +1414,7 @@ static gearman_return_t _client_run_task(gearman_client_st *client, gearman_task
   case GEARMAN_TASK_STATE_SUBMIT:
     while (1)
     {
-      gearman_return_t ret= task->con->send(&(task->send), client->new_tasks == 0 ? true : false);
+      gearman_return_t ret= task->con->send(task->send, client->new_tasks == 0 ? true : false);
 
       if (gearman_success(ret))
       {

libgearman/connection.cc

@@ -270,7 +270,7 @@ void gearman_connection_st::close()
   send_data_offset= 0;
 
   recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
-  if (recv_packet != NULL)
+  if (recv_packet)
   {
     gearman_packet_free(recv_packet);
     recv_packet= NULL;
@@ -291,12 +291,12 @@ void gearman_connection_st::reset_addrinfo()
   addrinfo_next= NULL;
 }
 
-gearman_return_t gearman_connection_st::send(const gearman_packet_st *packet_arg, const bool flush_buffer)
+gearman_return_t gearman_connection_st::send(const gearman_packet_st& packet_arg, const bool flush_buffer)
 {
   switch (send_state)
   {
   case GEARMAN_CON_SEND_STATE_NONE:
-    if (not (packet_arg->options.complete))
+    if (not (packet_arg.options.complete))
     {
       gearman_error(&universal, GEARMAN_INVALID_PACKET, "packet not complete");
       return GEARMAN_INVALID_PACKET;
@@ -307,7 +307,7 @@ gearman_return_t gearman_connection_st::send(const gearman_packet_st *packet_arg
     {
       gearman_return_t rc;
       { // Scoping to shut compiler up about switch/case jump
-        size_t send_size= gearman_packet_pack(*packet_arg,
+        size_t send_size= gearman_packet_pack(packet_arg,
                                               send_buffer + send_buffer_size,
                                               GEARMAN_SEND_BUFFER_SIZE -
                                               send_buffer_size, rc);
@@ -348,25 +348,24 @@ gearman_return_t gearman_connection_st::send(const gearman_packet_st *packet_arg
     }
 
     /* Return here if we have no data to send. */
-    if (not packet_arg->data_size)
+    if (not packet_arg.data_size)
     {
       break;
     }
 
     /* If there is any room in the buffer, copy in data. */
-    if (packet_arg->data and
+    if (packet_arg.data and
         (GEARMAN_SEND_BUFFER_SIZE - send_buffer_size) > 0)
     {
       send_data_offset= GEARMAN_SEND_BUFFER_SIZE - send_buffer_size;
-      if (send_data_offset > packet_arg->data_size)
-        send_data_offset= packet_arg->data_size;
+      if (send_data_offset > packet_arg.data_size)
+        send_data_offset= packet_arg.data_size;
 
-      memcpy(send_buffer + send_buffer_size, packet_arg->data,
-             send_data_offset);
+      memcpy(send_buffer + send_buffer_size, packet_arg.data, send_data_offset);
       send_buffer_size+= send_data_offset;
 
       /* Return if all data fit in the send buffer. */
-      if (send_data_offset == packet_arg->data_size)
+      if (send_data_offset == packet_arg.data_size)
       {
         send_data_offset= 0;
         break;
@@ -383,28 +382,28 @@ gearman_return_t gearman_connection_st::send(const gearman_packet_st *packet_arg
         return ret;
     }
 
-    send_data_size= packet_arg->data_size;
+    send_data_size= packet_arg.data_size;
 
     /* If this is NULL, then gearman_connection_send_data function will be used. */
-    if (not packet_arg->data)
+    if (not packet_arg.data)
     {
       send_state= GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA;
       return GEARMAN_SUCCESS;
     }
 
     /* Copy into the buffer if it fits, otherwise flush from packet buffer. */
-    send_buffer_size= packet_arg->data_size - send_data_offset;
+    send_buffer_size= packet_arg.data_size - send_data_offset;
     if (send_buffer_size < GEARMAN_SEND_BUFFER_SIZE)
     {
       memcpy(send_buffer,
-             static_cast<char *>(const_cast<void *>(packet_arg->data)) + send_data_offset,
+             static_cast<char *>(const_cast<void *>(packet_arg.data)) + send_data_offset,
              send_buffer_size);
       send_data_size= 0;
       send_data_offset= 0;
       break;
     }
 
-    send_buffer_ptr= static_cast<char *>(const_cast<void *>(packet_arg->data)) + send_data_offset;
+    send_buffer_ptr= static_cast<char *>(const_cast<void *>(packet_arg.data)) + send_data_offset;
     send_state= GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA;
 
   case GEARMAN_CON_SEND_UNIVERSAL_FLUSH:

libgearman/connection.hpp

@@ -85,7 +85,7 @@ struct gearman_connection_st
 
   void set_host( const char *host, const in_port_t port);
 
-  gearman_return_t send(const gearman_packet_st *packet, const bool flush_buffer);
+  gearman_return_t send(const gearman_packet_st&, const bool flush_buffer);
 
   size_t send(const void *data, size_t data_size, gearman_return_t *ret_ptr);
 

libgearman/job.cc

@@ -237,7 +237,7 @@ gearman_return_t gearman_job_send_data(gearman_job_st *job, const void *data, si
     args_size[0]= job->assigned.arg_size[0];
     args[1]= data;
     args_size[1]= data_size;
-    ret= gearman_packet_create_args(job->worker->universal, &(job->work),
+    ret= gearman_packet_create_args(job->worker->universal, job->work,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_WORK_DATA,
                                     args, args_size, 2);
@@ -265,7 +265,7 @@ gearman_return_t gearman_job_send_warning(gearman_job_st *job,
     args_size[1]= warning_size;
 
     gearman_return_t ret;
-    ret= gearman_packet_create_args(job->worker->universal, &(job->work),
+    ret= gearman_packet_create_args(job->worker->universal, job->work,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_WORK_WARNING,
                                     args, args_size, 2);
@@ -300,7 +300,7 @@ gearman_return_t gearman_job_send_status(gearman_job_st *job,
     args_size[2]= strlen(denominator_string);
 
     gearman_return_t ret;
-    ret= gearman_packet_create_args(job->worker->universal, &(job->work),
+    ret= gearman_packet_create_args(job->worker->universal, job->work,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_WORK_STATUS,
                                     args, args_size, 3);
@@ -361,7 +361,7 @@ gearman_return_t gearman_job_send_complete(gearman_job_st *job,
 
     args[1]= result;
     args_size[1]= result_size;
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, &(job->work),
+    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_COMPLETE,
                                                      args, args_size, 2);
@@ -397,7 +397,7 @@ gearman_return_t gearman_job_send_exception(gearman_job_st *job,
     args[1]= exception;
     args_size[1]= exception_size;
 
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, &(job->work),
+    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_EXCEPTION,
                                                      args, args_size, 2);
@@ -422,7 +422,7 @@ gearman_return_t gearman_job_send_fail(gearman_job_st *job)
   {
     args[0]= job->assigned.arg[0];
     args_size[0]= job->assigned.arg_size[0] - 1;
-    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, &(job->work),
+    gearman_return_t ret= gearman_packet_create_args(job->worker->universal, job->work,
                                                      GEARMAN_MAGIC_REQUEST,
                                                      GEARMAN_COMMAND_WORK_FAIL,
                                                      args, args_size, 1);
@@ -522,7 +522,7 @@ void gearman_job_free(gearman_job_st *job)
 
 static gearman_return_t _job_send(gearman_job_st *job)
 {
-  gearman_return_t ret= job->con->send(&(job->work), true);
+  gearman_return_t ret= job->con->send(job->work, true);
   if (gearman_failed(ret))
     return ret;
 

libgearman/packet.cc

@@ -193,45 +193,45 @@ gearman_return_t gearman_packet_create_arg(gearman_packet_st& self,
 }
 
 gearman_return_t gearman_packet_create_args(gearman_universal_st& universal,
-                                            gearman_packet_st *packet,
+                                            gearman_packet_st& packet,
                                             enum gearman_magic_t magic,
                                             gearman_command_t command,
                                             const void *args[],
                                             const size_t args_size[],
                                             size_t args_count)
 {
-  packet= gearman_packet_create(universal, packet);
-  if (not packet)
+  if (not gearman_packet_create(universal, &packet))
   {
+    gearman_perror(universal, "failed in gearman_packet_create()");
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
   }
 
-  packet->magic= magic;
-  packet->command= command;
+  packet.magic= magic;
+  packet.command= command;
 
-  if (gearman_command_info(packet->command)->data)
+  if (gearman_command_info(packet.command)->data)
   {
-    assert(args_count -1 == gearman_command_info(packet->command)->argc);
+    assert(args_count -1 == gearman_command_info(packet.command)->argc);
   }
   else
   {
-    assert(args_count == gearman_command_info(packet->command)->argc);
+    assert(args_count == gearman_command_info(packet.command)->argc);
   }
 
   for (size_t x= 0; x < args_count; x++)
   {
-    gearman_return_t ret= packet_create_arg(packet, args[x], args_size[x]);
+    gearman_return_t ret= packet_create_arg(&packet, args[x], args_size[x]);
     if (gearman_failed(ret))
     {
-      gearman_packet_free(packet);
+      gearman_packet_free(&packet);
       return ret;
     }
   }
 
-  gearman_return_t ret= gearman_packet_pack_header(packet);
+  gearman_return_t ret= gearman_packet_pack_header(&packet);
   if (gearman_failed(ret))
   {
-    gearman_packet_free(packet);
+    gearman_packet_free(&packet);
     return ret;
   }
 

libgearman/packet.hpp

@@ -67,7 +67,7 @@ void gearman_packet_free(gearman_packet_st*);
 
 GEARMAN_LOCAL
 gearman_return_t gearman_packet_create_args(gearman_universal_st&,
-                                            gearman_packet_st *packet,
+                                            gearman_packet_st& packet,
                                             enum gearman_magic_t magic,
                                             gearman_command_t command,
                                             const void *args[],

libgearman/universal.cc

@@ -294,7 +294,7 @@ gearman_return_t gearman_echo(gearman_universal_st& universal,
     return GEARMAN_INVALID_ARGUMENT;
   }
 
-  gearman_return_t ret= gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+  gearman_return_t ret= gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                    GEARMAN_COMMAND_ECHO_REQ,
                                                    &workload, &workload_size, 1);
   if (gearman_failed(ret))
@@ -308,7 +308,7 @@ gearman_return_t gearman_echo(gearman_universal_st& universal,
   {
     gearman_packet_st *packet_ptr;
 
-    ret= con->send(&packet, true);
+    ret= con->send(packet, true);
     if (gearman_failed(ret))
     {
       goto exit;
@@ -355,7 +355,7 @@ bool gearman_request_option(gearman_universal_st &universal,
   size_t args_size[]= { gearman_size(option) };
 
   gearman_return_t ret;
-  ret= gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+  ret= gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                   GEARMAN_COMMAND_OPTION_REQ,
                                   args, args_size, 1);
   if (gearman_failed(ret))
@@ -370,7 +370,7 @@ bool gearman_request_option(gearman_universal_st &universal,
   {
     gearman_packet_st *packet_ptr;
 
-    ret= con->send(&packet, true);
+    ret= con->send(packet, true);
     if (gearman_failed(ret))
     {
       gearman_packet_free(&(con->_packet));

libgearman/worker.cc

@@ -474,7 +474,7 @@ static inline gearman_return_t _worker_unregister(gearman_worker_st *worker,
 
   args[0]= function->name();
   args_size[0]= function->length();
-  ret= gearman_packet_create_args(worker->universal, &(function->packet),
+  ret= gearman_packet_create_args(worker->universal, function->packet,
                                   GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CANT_DO,
                                   args, args_size, 1);
   if (gearman_failed(ret))
@@ -519,7 +519,7 @@ gearman_return_t gearman_worker_unregister_all(gearman_worker_st *worker)
   gearman_packet_free(&(worker->function_list->packet));
 
   gearman_return_t ret= gearman_packet_create_args(worker->universal,
-						   &(worker->function_list->packet),
+						   worker->function_list->packet,
 						   GEARMAN_MAGIC_REQUEST,
 						   GEARMAN_COMMAND_RESET_ABILITIES,
 						   NULL, NULL, 0);
@@ -576,7 +576,7 @@ gearman_job_st *gearman_worker_grab_job(gearman_worker_st *worker,
               continue;
 
     case GEARMAN_WORKER_STATE_FUNCTION_SEND:
-            *ret_ptr= worker->con->send(&(worker->function->packet), true);
+            *ret_ptr= worker->con->send(worker->function->packet, true);
             if (gearman_failed(*ret_ptr))
             {
               if (*ret_ptr == GEARMAN_IO_WAIT)
@@ -629,7 +629,7 @@ gearman_job_st *gearman_worker_grab_job(gearman_worker_st *worker,
                worker->function= worker->function->next)
           {
     case GEARMAN_WORKER_STATE_CONNECT:
-            *ret_ptr= worker->con->send(&(worker->function->packet), true);
+            *ret_ptr= worker->con->send(worker->function->packet, true);
             if (gearman_failed(*ret_ptr))
             {
               if (*ret_ptr == GEARMAN_IO_WAIT)
@@ -653,7 +653,7 @@ gearman_job_st *gearman_worker_grab_job(gearman_worker_st *worker,
         if (worker->con->fd == -1)
           continue;
 
-        *ret_ptr= worker->con->send(&(worker->grab_job), true);
+        *ret_ptr= worker->con->send(worker->grab_job, true);
         if (gearman_failed(*ret_ptr))
         {
           if (*ret_ptr == GEARMAN_IO_WAIT)
@@ -745,7 +745,7 @@ gearman_job_st *gearman_worker_grab_job(gearman_worker_st *worker,
         if (worker->con->fd == -1)
           continue;
 
-        *ret_ptr= worker->con->send(&(worker->pre_sleep), true);
+        *ret_ptr= worker->con->send(worker->pre_sleep, true);
         if (gearman_failed(*ret_ptr))
         {
           if (*ret_ptr == GEARMAN_IO_WAIT)
@@ -1067,13 +1067,13 @@ static gearman_worker_st *_worker_allocate(gearman_worker_st *worker, bool is_cl
 
 static gearman_return_t _worker_packet_init(gearman_worker_st *worker)
 {
-  gearman_return_t ret= gearman_packet_create_args(worker->universal, &(worker->grab_job),
+  gearman_return_t ret= gearman_packet_create_args(worker->universal, worker->grab_job,
 						   GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_GRAB_JOB,
 						   NULL, NULL, 0);
   if (gearman_failed(ret))
     return ret;
 
-  ret= gearman_packet_create_args(worker->universal, &(worker->pre_sleep),
+  ret= gearman_packet_create_args(worker->universal, worker->pre_sleep,
 				  GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_PRE_SLEEP,
 				  NULL, NULL, 0);
   if (gearman_failed(ret))
@@ -1125,7 +1125,7 @@ static gearman_return_t _worker_function_create(gearman_worker_st *worker,
     args_size[0]= function->length() + 1;
     args[1]= timeout_buffer;
     args_size[1]= strlen(timeout_buffer);
-    ret= gearman_packet_create_args(worker->universal, &(function->packet),
+    ret= gearman_packet_create_args(worker->universal, function->packet,
                                     GEARMAN_MAGIC_REQUEST,
                                     GEARMAN_COMMAND_CAN_DO_TIMEOUT,
                                     args, args_size, 2);
@@ -1134,7 +1134,7 @@ static gearman_return_t _worker_function_create(gearman_worker_st *worker,
   {
     args[0]= function->name();
     args_size[0]= function->length();
-    ret= gearman_packet_create_args(worker->universal, &(function->packet),
+    ret= gearman_packet_create_args(worker->universal, function->packet,
 				    GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
 				    args, args_size, 1);
   }

tests/regression.cc

@@ -91,28 +91,28 @@ static test_return_t bug372074_test(void *)
 
     args[0]= "testUnregisterFunction";
     args_size[0]= strlen("testUnregisterFunction");
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                           GEARMAN_COMMAND_SET_CLIENT_ID,
                                                           args, args_size, 1)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);
 
     args[0]= "reverse";
     args_size[0]= strlen("reverse");
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
                                                           args, args_size, 1)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);
 
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                           GEARMAN_COMMAND_CANT_DO,
                                                           args, args_size, 1)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);
 
@@ -124,39 +124,39 @@ static test_return_t bug372074_test(void *)
 
     args[0]= "testUnregisterFunction";
     args_size[0]= strlen("testUnregisterFunction");
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                           GEARMAN_COMMAND_SET_CLIENT_ID,
                                                           args, args_size, 1)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);
 
     args[0]= "digest";
     args_size[0]= strlen("digest");
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                           GEARMAN_COMMAND_CAN_DO,
                                                           args, args_size, 1)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);
 
     args[0]= "reverse";
     args_size[0]= strlen("reverse");
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                           GEARMAN_COMMAND_CAN_DO,
                                                           args, args_size, 1)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);
 
-    test_truth(gearman_success(gearman_packet_create_args(universal, &packet, GEARMAN_MAGIC_REQUEST,
+    test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                           GEARMAN_COMMAND_RESET_ABILITIES,
                                                           NULL, NULL, 0)));
 
-    test_truth(gearman_success(con_ptr->send(&packet, true)));
+    test_truth(gearman_success(con_ptr->send(packet, true)));
 
     gearman_packet_free(&packet);