00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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