Bug Summary

File:activesyncd/eas-daemon/libeas/eas-request-base.c
Warning:line 213, column 9
Access to field 'do_MessageComplete' results in a dereference of a null pointer (loaded from field 'g_class')

Annotated Source Code

1/*
2 * ActiveSync core protocol library
3 *
4 * Copyright © 2011 Intel Corporation.
5 *
6 * Authors: Mobica Ltd. <www.mobica.com>
7 *
8 * This file is provided under a dual Apache/LGPLv2.1 licence. When
9 * using or redistributing this file, you may do so under either
10 * licence.
11 *
12 *
13 * LGPLv2.1 LICENCE SUMMARY
14 *
15 * Copyright © Intel Corporation, dates as above.
16 *
17 * This library is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU Lesser General Public
19 * License as published by the Free Software Foundation; either
20 * version 2.1 of the License, or (at your option) any later
21 * version.
22 *
23 * This library is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 * Lesser General Public License for more details.
27 *
28 * You should have received a copy of the GNU Lesser General Public
29 * License along with this library; if not, write to the Free
30 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
31 * Boston, MA 02110-1301 USA
32 *
33 *
34 * APACHE LICENCE SUMMARY
35 *
36 * Copyright © Intel Corporation, dates as above.
37 *
38 * Licensed under the Apache License, Version 2.0 (the "License");
39 * you may not use this file except in compliance with the License.
40 * You may obtain a copy of the License at
41 *
42 * http://www.apache.org/licenses/LICENSE-2.0
43 *
44 * Unless required by applicable law or agreed to in writing, software
45 * distributed under the License is distributed on an "AS IS" BASIS,
46 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
47 * See the License for the specific language governing permissions and
48 * limitations under the License.
49 *
50 */
51
52#include "eas-request-base.h"
53
54struct _EasRequestBasePrivate {
55 EasRequestType requestType;
56 struct _EasConnection* connection;
57 SoupMessage *soup_message;
58 EFlag *flag;
59 DBusGMethodInvocation *context;
60 EasInterfaceBase *dbus_interface;
61 gboolean outgoing_progress; // whether the progress updates are for outgoing/incoming data
62 gchar *request_owner; // dbus sender of message
63 guint request_id; // passed back with progress signal
64 gboolean cancelled; // whether the request has been cancelled
65 guint data_length_so_far; // amount of data received/sent so far
66 guint data_size; // total size of response/request data
67 gboolean use_multipart;
68 guchar* wbxml;
69 gsize wbxml_length;
70};
71
72#define EAS_REQUEST_BASE_PRIVATE(o)(((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((o)), ((eas_request_base_get_type ())))))
(G_TYPE_INSTANCE_GET_PRIVATE ((o), EAS_TYPE_REQUEST_BASE, EasRequestBasePrivate)((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((o)), ((eas_request_base_get_type ()))))
)
73
74G_DEFINE_TYPE (EasRequestBase, eas_request_base, G_TYPE_OBJECT)static void eas_request_base_init (EasRequestBase *self); static
void eas_request_base_class_init (EasRequestBaseClass *klass
); static gpointer eas_request_base_parent_class = ((void*)0)
; static gint EasRequestBase_private_offset; static void eas_request_base_class_intern_init
(gpointer klass) { eas_request_base_parent_class = g_type_class_peek_parent
(klass); if (EasRequestBase_private_offset != 0) g_type_class_adjust_private_offset
(klass, &EasRequestBase_private_offset); eas_request_base_class_init
((EasRequestBaseClass*) klass); } __attribute__((__unused__)
) static inline gpointer eas_request_base_get_instance_private
(EasRequestBase *self) { return (((gpointer) ((guint8*) (self
) + (glong) (EasRequestBase_private_offset)))); } GType eas_request_base_get_type
(void) { static volatile gsize g_define_type_id__volatile = 0
; if ((__extension__ ({ typedef char _GStaticAssertCompileTimeAssertion_4
[(sizeof *(&g_define_type_id__volatile) == sizeof (gpointer
)) ? 1 : -1] __attribute__((__unused__)); (void) (0 ? (gpointer
) *(&g_define_type_id__volatile) : 0); (!(__extension__ (
{ typedef char _GStaticAssertCompileTimeAssertion_5[(sizeof *
(&g_define_type_id__volatile) == sizeof (gpointer)) ? 1 :
-1] __attribute__((__unused__)); __sync_synchronize (); (gpointer
) *(&g_define_type_id__volatile); })) && g_once_init_enter
(&g_define_type_id__volatile)); }))) { GType g_define_type_id
= g_type_register_static_simple (((GType) ((20) << (2)
)), g_intern_static_string ("EasRequestBase"), sizeof (EasRequestBaseClass
), (GClassInitFunc) eas_request_base_class_intern_init, sizeof
(EasRequestBase), (GInstanceInitFunc) eas_request_base_init,
(GTypeFlags) 0); { {{};} } (__extension__ ({ typedef char _GStaticAssertCompileTimeAssertion_6
[(sizeof *(&g_define_type_id__volatile) == sizeof (gpointer
)) ? 1 : -1] __attribute__((__unused__)); (void) (0 ? *(&
g_define_type_id__volatile) = (g_define_type_id) : 0); g_once_init_leave
((&g_define_type_id__volatile), (gsize) (g_define_type_id
)); })); } return g_define_type_id__volatile; }
;
75
76void _eas_request_base_GotChunk (EasRequestBase *self, SoupMessage *msg, SoupBuffer *chunk);
77
78guchar*
79eas_request_base_GetWbxmlFromChunking (EasRequestBase *self)
80{
81 return EAS_REQUEST_BASE_PRIVATE (self)(((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((self)), ((eas_request_base_get_type ())))))
->wbxml;
82}
83
84gsize
85eas_request_base_GetWbxmlFromChunkingSize (EasRequestBase *self)
86{
87 return EAS_REQUEST_BASE_PRIVATE (self)(((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((self)), ((eas_request_base_get_type ())))))
->wbxml_length;
88}
89
90
91void
92eas_request_base_SetWbxmlFromChunking (EasRequestBase *self, guchar* wbxml, gsize wbxml_length)
93{
94 EasRequestBasePrivate *priv = EAS_REQUEST_BASE_PRIVATE (self)(((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((self)), ((eas_request_base_get_type ())))))
;
95
96 g_free (priv->wbxml);
97 priv->wbxml_length = 0;
98
99 priv->wbxml = g_malloc0 (wbxml_length);
100 if (priv->wbxml) {
101 memcpy (priv->wbxml, wbxml, wbxml_length);
102 priv->wbxml_length = wbxml_length;
103 }
104}
105
106
107static void
108eas_request_base_init (EasRequestBase *object)
109{
110 EasRequestBasePrivate *priv;
111
112 object->priv = priv = EAS_REQUEST_BASE_PRIVATE (object)(((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((object)), ((eas_request_base_get_type ())))))
;
113
114 g_debug ("eas_request_base_init++");
115
116 priv->requestType = EAS_REQ_BASE;
117 priv->connection = NULL((void*)0);
118 priv->soup_message = NULL((void*)0);
119 priv->flag = NULL((void*)0);
120 priv->context = NULL((void*)0);
121 priv->dbus_interface = NULL((void*)0);
122 priv->data_length_so_far = 0;
123 priv->data_size = 0;
124 priv->request_id = 0;
125 priv->request_owner = NULL((void*)0);
126 priv->cancelled = FALSE(0);
127 priv->use_multipart = FALSE(0);
128 priv->wbxml = NULL((void*)0);
129
130 g_debug ("eas_request_base_init--");
131}
132
133static void
134eas_request_base_dispose (GObject *object)
135{
136 EasRequestBase *req = (EasRequestBase *) object;
137 EasRequestBasePrivate *priv = req->priv;
138
139 g_debug ("eas_request_base_dispose++");
140 if(priv->connection){
141 g_debug("not unrefing connection");
142 // TODO Fix the unref count.
143 // g_object_unref(priv->connection);
144 // priv->connection = NULL;
145 }
146 G_OBJECT_CLASS (eas_request_base_parent_class)((((GObjectClass*) g_type_check_class_cast ((GTypeClass*) ((eas_request_base_parent_class
)), (((GType) ((20) << (2))))))))
->dispose (object);
147 g_debug ("eas_request_base_dispose--");
148}
149
150static void
151eas_request_base_finalize (GObject *object)
152{
153 EasRequestBasePrivate *priv = EAS_REQUEST_BASE_PRIVATE (object)(((EasRequestBasePrivate*) g_type_instance_get_private ((GTypeInstance
*) ((object)), ((eas_request_base_get_type ())))))
;
154
155 g_debug ("eas_request_base_finalize++");
156 g_free (priv->wbxml);
157 g_free (priv->request_owner);
158 G_OBJECT_CLASS (eas_request_base_parent_class)((((GObjectClass*) g_type_check_class_cast ((GTypeClass*) ((eas_request_base_parent_class
)), (((GType) ((20) << (2))))))))
->finalize (object);
159 g_debug ("eas_request_base_finalize--");
160}
161
162static void
163eas_request_base_class_init (EasRequestBaseClass *klass)
164{
165 GObjectClass* object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) g_type_check_class_cast ((GTypeClass*) ((klass
)), (((GType) ((20) << (2))))))))
;
166
167 g_debug ("eas_request_base_class_init++");
168 g_type_class_add_private (klass, sizeof (EasRequestBasePrivate));
169
170 object_class->finalize = eas_request_base_finalize;
171 object_class->dispose = eas_request_base_dispose;
172
173 klass->do_MessageComplete = NULL((void*)0);
174 klass->do_GotChunk = _eas_request_base_GotChunk;
175
176 g_debug ("eas_request_base_class_init--");
177}
178
179EasRequestType
180eas_request_base_GetRequestType (EasRequestBase* self)
181{
182 EasRequestBasePrivate *priv = self->priv;
183
184 return priv->requestType;
185}
186
187void
188_eas_request_base_GotChunk (EasRequestBase *self,
189 SoupMessage *msg,
190 SoupBuffer *chunk)
191{
192 g_debug ("_eas_request_base_GotChunk+-");
193}
194
195void
196eas_request_base_GotChunk (EasRequestBase *self,
197 SoupMessage *msg,
198 SoupBuffer *chunk)
199{
200 g_debug ("eas_request_base_GotChunk+-");
201 EAS_REQUEST_BASE_GET_CLASS (self)((((EasRequestBaseClass*) (((GTypeInstance*) ((self)))->g_class
))))
->do_GotChunk (self, msg, chunk);
202}
203
204gboolean
205eas_request_base_MessageComplete (EasRequestBase *self,
206 xmlDoc* doc,
207 GError* error_in)
208{
209 g_return_val_if_fail (EAS_IS_REQUEST_BASE (self), TRUE)do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_
; if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((self)); GType __t = ((eas_request_base_get_type ())); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) _g_boolean_var_
= 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else
{ g_return_if_fail_warning ("libeas", ((const char*) (__func__
)), "EAS_IS_REQUEST_BASE (self)"); return ((!(0))); }; }while
(0)
;
1
Within the expansion of the macro 'g_return_val_if_fail':
a
Assuming '__inst' is non-null
b
Assuming pointer value is null
c
Assuming the condition is true
210
211 g_debug ("eas_request_base_MessageComplete+-");
212
213 return EAS_REQUEST_BASE_GET_CLASS (self)((((EasRequestBaseClass*) (((GTypeInstance*) ((self)))->g_class
))))
->do_MessageComplete (self, doc, error_in);
2
Within the expansion of the macro 'EAS_REQUEST_BASE_GET_CLASS':
a
Access to field 'do_MessageComplete' results in a dereference of a null pointer (loaded from field 'g_class')
214}
215
216gboolean
217eas_request_base_SendRequest (EasRequestBase* self,
218 const gchar* cmd,
219 xmlDoc *doc,
220 gboolean highpriority,
221 GError **error)
222{
223 EasRequestBasePrivate *priv = self->priv;
224
225 g_debug ("eas_request_base_SendRequest");
226
227 return eas_connection_send_request (priv->connection,
228 cmd,
229 doc, // full transfer
230 self,
231 highpriority,
232 error);
233}
234
235void
236eas_request_base_SetRequestType (EasRequestBase* self, EasRequestType type)
237{
238 EasRequestBasePrivate *priv = self->priv;
239 g_debug ("eas_request_base_SetRequestType++");
240 priv->requestType = type;
241 g_debug ("eas_request_base_SetRequestType--");
242}
243
244guint
245eas_request_base_GetRequestId (EasRequestBase* self)
246{
247 EasRequestBasePrivate *priv = self->priv;
248
249 return priv->request_id;
250}
251
252void
253eas_request_base_SetRequestId (EasRequestBase* self, guint request_id)
254{
255 EasRequestBasePrivate *priv = self->priv;
256
257 priv->request_id = request_id;
258
259 return ;
260}
261
262const gchar *
263eas_request_base_GetRequestOwner (EasRequestBase* self)
264{
265 EasRequestBasePrivate *priv = self->priv;
266
267 return priv->request_owner;
268}
269
270void
271eas_request_base_SetRequestOwner (EasRequestBase* self, gchar *request_owner)
272{
273 EasRequestBasePrivate *priv = self->priv;
274
275 priv->request_owner = request_owner;
276
277 return ;
278}
279
280gboolean
281eas_request_base_IsCancelled (EasRequestBase* self)
282{
283 EasRequestBasePrivate *priv = self->priv;
284
285 return priv->cancelled;
286
287}
288
289void
290eas_request_base_Cancelled (EasRequestBase* self)
291{
292 EasRequestBasePrivate *priv = self->priv;
293
294 priv->cancelled = TRUE(!(0));
295
296 return;
297}
298
299
300gboolean
301eas_request_base_GetRequestProgressDirection (EasRequestBase* self)
302{
303 EasRequestBasePrivate *priv = self->priv;
304
305 return priv->outgoing_progress;
306}
307
308void
309eas_request_base_SetRequestProgressDirection (EasRequestBase* self, gboolean outgoing_progress)
310{
311 EasRequestBasePrivate *priv = self->priv;
312
313 priv->outgoing_progress = outgoing_progress;
314
315 return ;
316}
317
318guint
319eas_request_base_GetDataSize (EasRequestBase* self)
320{
321 EasRequestBasePrivate *priv = self->priv;
322
323 return priv->data_size;
324}
325
326void
327eas_request_base_SetDataSize (EasRequestBase* self, guint size)
328{
329 EasRequestBasePrivate *priv = self->priv;
330
331 g_debug ("eas_request_base_SetDataSize++");
332
333 priv->data_size = size;
334
335 g_debug ("eas_request_base_SetDataSize--");
336
337 return;
338}
339
340guint
341eas_request_base_GetDataLengthSoFar (EasRequestBase* self)
342{
343 EasRequestBasePrivate *priv = self->priv;
344
345 return priv->data_length_so_far;
346}
347
348void
349eas_request_base_UpdateDataLengthSoFar (EasRequestBase* self, guint length)
350{
351 EasRequestBasePrivate *priv = self->priv;
352
353 priv->data_length_so_far += length;
354
355 return;
356}
357
358void
359eas_request_base_SetDataLengthSoFar (EasRequestBase* self, guint length)
360{
361 EasRequestBasePrivate *priv = self->priv;
362
363 priv->data_length_so_far = length;
364
365 return;
366}
367
368struct _EasConnection*
369eas_request_base_GetConnection (EasRequestBase* self) {
370 EasRequestBasePrivate *priv = self->priv;
371 g_debug ("eas_request_base_GetConnection++ %p", priv->connection);
372 return priv->connection;
373}
374
375void
376eas_request_base_SetConnection (EasRequestBase* self, struct _EasConnection* connection)
377{
378 EasRequestBasePrivate *priv = self->priv;
379 g_debug ("eas_request_base_SetConnection++ [%p]", connection);
380 priv->connection = connection;
381 g_debug ("eas_request_base_SetConnection--");
382}
383
384
385void
386eas_request_base_SetInterfaceObject (EasRequestBase* self, EasInterfaceBase *dbus_interface)
387{
388 EasRequestBasePrivate *priv = self->priv;
389 g_debug ("eas_request_base_SetInterfaceObject++");
390 priv->dbus_interface = dbus_interface;
391 g_debug ("eas_request_base_SetInterfaceObject--");
392}
393
394EasInterfaceBase*
395eas_request_base_GetInterfaceObject (EasRequestBase* self)
396{
397 EasRequestBasePrivate *priv = self->priv;
398 return priv->dbus_interface;
399}
400
401
402SoupMessage *
403eas_request_base_GetSoupMessage (EasRequestBase *self)
404{
405 EasRequestBasePrivate *priv = self->priv;
406 g_debug ("eas_request_base_SoupMessage++ %lx", (unsigned long) priv->soup_message);
407 return priv->soup_message;
408}
409
410void
411eas_request_base_SetSoupMessage (EasRequestBase *self, SoupMessage *soup_message)
412{
413 EasRequestBasePrivate *priv = self->priv;
414 g_debug ("eas_request_base_SetSoupMessage++");
415 priv->soup_message = soup_message;
416 g_debug ("eas_request_base_SetSoupMessage--");
417}
418
419EFlag *
420eas_request_base_GetFlag (EasRequestBase* self)
421{
422 EasRequestBasePrivate *priv = self->priv;
423 g_debug ("eas_request_base_GetFlag+-");
424 return priv->flag;
425}
426
427void
428eas_request_base_SetFlag (EasRequestBase* self, EFlag* flag)
429{
430 EasRequestBasePrivate *priv = self->priv;
431 g_debug ("eas_request_base_SetFlag++");
432 priv->flag = flag;
433 g_debug ("eas_request_base_SetFlag--");
434}
435
436DBusGMethodInvocation*
437eas_request_base_GetContext (EasRequestBase* self)
438{
439 EasRequestBasePrivate *priv = self->priv;
440 g_debug ("eas_request_base_GetContext+-");
441 return priv->context;
442}
443
444void
445eas_request_base_SetContext (EasRequestBase* self, DBusGMethodInvocation* context)
446{
447 EasRequestBasePrivate *priv = self->priv;
448 g_debug ("eas_request_base_SetContext++");
449 priv->context = context;
450 g_debug ("eas_request_base_SetContext--");
451}
452
453gboolean
454eas_request_base_UseMultipart (EasRequestBase* self)
455{
456 return self->priv->use_multipart;
457}
458void eas_request_base_Set_UseMultipart (EasRequestBase* self, gboolean use_multipart)
459{
460 self->priv->use_multipart = use_multipart;
461}