OpenSync  0.22
opensync_message.c
1 /*
2  * libosengine - A synchronization engine for the opensync framework
3  * Copyright (C) 2004-2005 Armin Bauer <armin.bauer@opensync.org>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  */
20 
21 #include "opensync.h"
22 #include "opensync_internals.h"
23 
31 
44 {
45  OSyncMessage *message = osync_try_malloc0(sizeof(OSyncMessage), error);
46  if (!message)
47  return NULL;
48 
49  message->cmd = cmd;
50  message->refCount = 1;
51  if (size > 0)
52  message->buffer = g_byte_array_sized_new( size );
53  else
54  message->buffer = g_byte_array_new();
55  message->buffer_read_pos = 0;
56  return message;
57 }
58 
59 void osync_message_ref(OSyncMessage *message)
60 {
61  g_atomic_int_inc(&(message->refCount));
62 }
63 
64 void osync_message_unref(OSyncMessage *message)
65 {
66  if (g_atomic_int_dec_and_test(&(message->refCount))) {
67 
68  g_byte_array_free(message->buffer, TRUE);
69 
70  g_free(message);
71  }
72 }
73 
82 void osync_message_set_handler(OSyncMessage *message, OSyncMessageHandler handler, gpointer user_data)
83 {
84  osync_trace(TRACE_INTERNAL, "%p handler to %p", message, user_data);
85  message->user_data = user_data;
86  message->callback = handler;
87 }
88 
97 {
98  OSyncMessage *reply = osync_message_new(OSYNC_MESSAGE_REPLY, 0, error);
99  if (!reply)
100  return NULL;
101 
102  reply->id1 = message->id1;
103  reply->id2 = message->id2;
104  return reply;
105 }
106 
114 {
115  OSyncMessage *reply = osync_message_new(OSYNC_MESSAGE_ERRORREPLY, 0, error);
116  if (!reply)
117  return NULL;
118 
119  reply->id1 = message->id1;
120  reply->id2 = message->id2;
121  return reply;
122 }
123 
124 OSyncMessage *osync_message_new_error(OSyncError *error, OSyncError **loc_error)
125 {
126  OSyncMessage *message = osync_message_new(OSYNC_MESSAGE_ERROR, 0, loc_error);
127  if (!message)
128  return NULL;
129 
130  osync_marshal_error(message, error);
131 
132  return message;
133 }
134 
142 {
143  if (message->cmd == OSYNC_MESSAGE_ERRORREPLY)
144  return TRUE;
145  return FALSE;
146 }
147 
148 osync_bool osync_message_is_answered(OSyncMessage *message)
149 {
150  return message->is_answered;
151 }
152 
153 void osync_message_set_answered(OSyncMessage *message)
154 {
155  message->is_answered = TRUE;
156 }
157 
166 {
167  g_assert(message);
168  return message->cmd;
169 }
170 
173 void osync_message_write_int(OSyncMessage *message, int value)
174 {
175  g_byte_array_append( message->buffer, (unsigned char*)&value, sizeof( int ) );
176 }
177 
178 void osync_message_write_long_long_int(OSyncMessage *message, long long int value)
179 {
180  g_byte_array_append( message->buffer, (unsigned char*)&value, sizeof( long long int ) );
181 }
182 
183 void osync_message_write_string(OSyncMessage *message, const char *value)
184 {
185  int length = 0;
186  if (value == NULL) {
187  length = -1;
188  g_byte_array_append( message->buffer, (unsigned char*)&length, sizeof( int ) );
189  } else {
190  int length = strlen( value ) + 1;
191  g_byte_array_append( message->buffer, (unsigned char*)&length, sizeof( int ) );
192  g_byte_array_append( message->buffer, (unsigned char*)value, length );
193  }
194 }
195 
196 void osync_message_write_data(OSyncMessage *message, const void *value, int size)
197 {
198  g_byte_array_append( message->buffer, value, size );
199 }
200 
201 void osync_message_read_int(OSyncMessage *message, int *value)
202 {
203  memcpy(value, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(int));
204  message->buffer_read_pos += sizeof(int);
205 }
206 
207 void osync_message_read_long_long_int(OSyncMessage *message, long long int *value)
208 {
209  memcpy(value, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(long long int));
210  message->buffer_read_pos += sizeof(long long int);
211 }
212 
213 void osync_message_read_const_string(OSyncMessage *message, char **value)
214 {
215  int length = 0;
216  memcpy(&length, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(int));
217  message->buffer_read_pos += sizeof(int);
218 
219  if (length == -1) {
220  *value = NULL;
221  return;
222  }
223  *value = (char *)&(message->buffer->data[message->buffer_read_pos]);
224  message->buffer_read_pos += length;
225 }
226 
227 void osync_message_read_string(OSyncMessage *message, char **value)
228 {
229  int length = 0;
230  memcpy(&length, &(message->buffer->data[ message->buffer_read_pos ]), sizeof(int));
231  message->buffer_read_pos += sizeof(int);
232 
233  if (length == -1) {
234  *value = NULL;
235  return;
236  }
237  *value = (char*)malloc(length);
238  memcpy(*value, &(message->buffer->data[ message->buffer_read_pos ]), length );
239  message->buffer_read_pos += length;
240 }
241 
242 void osync_message_read_const_data(OSyncMessage *message, void **value, int size)
243 {
244  *value = &(message->buffer->data[message->buffer_read_pos]);
245  message->buffer_read_pos += size;
246 }
247 
248 void osync_message_read_data(OSyncMessage *message, void *value, int size)
249 {
250  memcpy(value, &(message->buffer->data[ message->buffer_read_pos ]), size );
251  message->buffer_read_pos += size;
252 }
253 
Represent an error.
OSyncMessage * osync_message_new_reply(OSyncMessage *message, OSyncError **error)
Creates a new reply.
OSyncMessageHandler callback
void(* OSyncMessageHandler)(OSyncMessage *message, void *user_data)
Function which can receive messages.
void osync_message_set_handler(OSyncMessage *message, OSyncMessageHandler handler, gpointer user_data)
Sets the handler that will receive the reply.
OSyncMessageCommand cmd
OSyncMessage * osync_message_new_errorreply(OSyncMessage *message, OSyncError **error)
Creates a new error reply.
void * osync_try_malloc0(unsigned int size, OSyncError **error)
Safely tries to malloc memory.
Definition: opensync_env.c:796
OSyncMessageCommand osync_message_get_command(OSyncMessage *message)
Gets the command from a message.
gboolean osync_message_is_error(OSyncMessage *message)
Checks if the message is a error.
void osync_trace(OSyncTraceType type, const char *message,...)
Used for tracing the application.
OSyncMessageCommand
The Type of the message.
OSyncMessage * osync_message_new(OSyncMessageCommand cmd, int size, OSyncError **error)
A Message used by the inter thread messaging library.