• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List

opensync/opensync_message.c

00001 /*
00002  * libosengine - A synchronization engine for the opensync framework
00003  * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
00004  * 
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU Lesser General Public
00007  * License as published by the Free Software Foundation; either
00008  * version 2.1 of the License, or (at your option) any later version.
00009  * 
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * Lesser General Public License for more details.
00014  * 
00015  * You should have received a copy of the GNU Lesser General Public
00016  * License along with this library; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
00018  * 
00019  */
00020  
00021 #include "opensync.h"
00022 #include "opensync_internals.h"
00023 
00031 
00043 OSyncMessage *osync_message_new(OSyncMessageCommand cmd, int size, OSyncError **error)
00044 {
00045         OSyncMessage *message = osync_try_malloc0(sizeof(OSyncMessage), error);
00046         if (!message)
00047                 return NULL;
00048 
00049         message->cmd = cmd;
00050         message->refCount = 1;
00051         if (size > 0)
00052                 message->buffer = g_byte_array_sized_new( size );
00053         else
00054                 message->buffer = g_byte_array_new();
00055         message->buffer_read_pos = 0;
00056         return message;
00057 }
00058 
00059 void osync_message_ref(OSyncMessage *message)
00060 {
00061         g_atomic_int_inc(&(message->refCount));
00062 }
00063 
00064 void osync_message_unref(OSyncMessage *message)
00065 {
00066         if (g_atomic_int_dec_and_test(&(message->refCount))) {
00067                 
00068                 g_byte_array_free(message->buffer, TRUE);
00069                 
00070                 g_free(message);
00071         }
00072 }
00073 
00082 void osync_message_set_handler(OSyncMessage *message, OSyncMessageHandler handler, gpointer user_data)
00083 {
00084         osync_trace(TRACE_INTERNAL, "%p handler to %p", message, user_data);
00085         message->user_data = user_data;
00086         message->callback = handler;
00087 }
00088 
00096 OSyncMessage *osync_message_new_reply(OSyncMessage *message, OSyncError **error)
00097 {
00098         OSyncMessage *reply = osync_message_new(OSYNC_MESSAGE_REPLY, 0, error);
00099         if (!reply)
00100                 return NULL;
00101 
00102         reply->id1 = message->id1;
00103         reply->id2 = message->id2;
00104         return reply;
00105 }
00106 
00113 OSyncMessage *osync_message_new_errorreply(OSyncMessage *message, OSyncError **error)
00114 {
00115         OSyncMessage *reply = osync_message_new(OSYNC_MESSAGE_ERRORREPLY, 0, error);
00116         if (!reply)
00117                 return NULL;
00118 
00119         reply->id1 = message->id1;
00120         reply->id2 = message->id2;
00121         return reply;
00122 }
00123 
00124 OSyncMessage *osync_message_new_error(OSyncError *error, OSyncError **loc_error)
00125 {
00126         OSyncMessage *message = osync_message_new(OSYNC_MESSAGE_ERROR, 0, loc_error);
00127         if (!message)
00128                 return NULL;
00129 
00130         osync_marshal_error(message, error);
00131         
00132         return message;
00133 }
00134 
00141 gboolean osync_message_is_error(OSyncMessage *message)
00142 {
00143         if (message->cmd == OSYNC_MESSAGE_ERRORREPLY)
00144                 return TRUE;
00145         return FALSE;
00146 }
00147 
00148 osync_bool osync_message_is_answered(OSyncMessage *message)
00149 {
00150         return message->is_answered;
00151 }
00152 
00153 void osync_message_set_answered(OSyncMessage *message)
00154 {
00155         message->is_answered = TRUE;
00156 }
00157 
00165 OSyncMessageCommand osync_message_get_command(OSyncMessage *message)
00166 {
00167         g_assert(message);
00168         return message->cmd;
00169 }
00170 
00173 void osync_message_write_int(OSyncMessage *message, int value)
00174 {
00175         g_byte_array_append( message->buffer, (unsigned char*)&value, sizeof( int ) );
00176 }
00177 
00178 void osync_message_write_long_long_int(OSyncMessage *message, long long int value)
00179 {
00180         g_byte_array_append( message->buffer, (unsigned char*)&value, sizeof( long long int ) );
00181 }
00182 
00183 void osync_message_write_string(OSyncMessage *message, const char *value)
00184 {
00185         int length = 0;
00186         if (value == NULL) {
00187                 length = -1;
00188                 g_byte_array_append( message->buffer, (unsigned char*)&length, sizeof( int ) );
00189         } else {
00190                 int length = strlen( value ) + 1;
00191                 g_byte_array_append( message->buffer, (unsigned char*)&length, sizeof( int ) );
00192                 g_byte_array_append( message->buffer, (unsigned char*)value, length );
00193         }
00194 }
00195 
00196 void osync_message_write_data(OSyncMessage *message, const void *value, int size)
00197 {
00198         g_byte_array_append( message->buffer, value, size );
00199 }
00200 
00201 void osync_message_read_int(OSyncMessage *message, int *value)
00202 {
00203         memcpy(value, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(int));
00204         message->buffer_read_pos += sizeof(int);
00205 }
00206 
00207 void osync_message_read_long_long_int(OSyncMessage *message, long long int *value)
00208 {
00209         memcpy(value, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(long long int));
00210         message->buffer_read_pos += sizeof(long long int);
00211 }
00212 
00213 void osync_message_read_const_string(OSyncMessage *message, char **value)
00214 {
00215         int length = 0;
00216         memcpy(&length, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(int));
00217         message->buffer_read_pos += sizeof(int);
00218 
00219         if (length == -1) {
00220                 *value = NULL;
00221                 return;
00222         }
00223         *value = (char *)&(message->buffer->data[message->buffer_read_pos]);
00224         message->buffer_read_pos += length;
00225 }
00226 
00227 void osync_message_read_string(OSyncMessage *message, char **value)
00228 {
00229         int length = 0;
00230         memcpy(&length, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(int));
00231         message->buffer_read_pos += sizeof(int);
00232 
00233         if (length == -1) {
00234                 *value = NULL;
00235                 return;
00236         }
00237         *value = (char*)malloc(length);
00238         memcpy(*value, &(message->buffer->data[ message->buffer_read_pos ]), length );
00239         message->buffer_read_pos += length;
00240 }
00241 
00242 void osync_message_read_const_data(OSyncMessage *message, void **value, int size)
00243 {
00244         *value = &(message->buffer->data[message->buffer_read_pos]);
00245         message->buffer_read_pos += size;
00246 }
00247 
00248 void osync_message_read_data(OSyncMessage *message, void *value, int size)
00249 {
00250         memcpy(value, &(message->buffer->data[ message->buffer_read_pos ]), size );
00251         message->buffer_read_pos += size;
00252 }
00253 

Generated on Sat Aug 13 2011 for OpenSync by  doxygen 1.7.1