gi/pygi-marshal-cleanup.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * vim: tabstop=4 shiftwidth=4 expandtab
   3  *
   4  * Copyright (C) 2011 John (J5) Palmieri <johnp@redhat.com>, Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  19  * USA
  20  */
  21
  22  #include "pygi-marshal-cleanup.h"
  23  #include <glib.h>
  24 static inline void
  25 _cleanup_caller_allocates (PyGIInvokeState    *state,
  26                            PyGIArgCache       *cache,
  27                            gpointer            data)
  28 {
  29     PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *)cache;
  30
  31     if (iface_cache->g_type == G_TYPE_BOXED) {
  32         gsize size;
  33         size = g_struct_info_get_size (iface_cache->interface_info);
  34         g_slice_free1 (size, data);
  35     } else if (iface_cache->g_type == G_TYPE_VALUE) {
  36         g_slice_free (GValue, data);
  37     } else if (iface_cache->is_foreign) {
  38         pygi_struct_foreign_release ((GIBaseInfo *)iface_cache->interface_info,
  39                                      data);
  40     } else {
  41         g_free (data);
  42     }
  43 }
  44
  45 /**
  46  * Cleanup during invoke can happen in multiple
  47  * stages, each of which can be the result of a
  48  * successful compleation of that stage or an error
  49  * occured which requires partial cleanup.
  50  *
  51  * For the most part, either the C interface being
  52  * invoked or the python object which wraps the
  53  * parameters, handle their lifecycles but in some
  54  * cases, where we have intermediate objects,
  55  * or when we fail processing a parameter, we need
  56  * to handle the clean up manually.
  57  *
  58  * There are two argument processing stages.
  59  * They are the in stage, where we process python
  60  * parameters into their C counterparts, and the out
  61  * stage, where we process out C parameters back
  62  * into python objects. The in stage also sets up
  63  * temporary out structures for caller allocated
  64  * parameters which need to be cleaned up either on
  65  * in stage failure or at the completion of the out
  66  * stage (either success or failure)
  67  *
  68  * The in stage must call one of these cleanup functions:
  69  *    - pygi_marshal_cleanup_args_from_py_marshal_success
  70  *       (continue to out stage)
  71  *    - pygi_marshal_cleanup_args_from_py_parameter_fail
  72  *       (final, exit from invoke)
  73  *
  74  * The out stage must call one of these cleanup functions which are all final:
  75  *    - pygi_marshal_cleanup_args_to_py_marshal_success
  76  *    - pygi_marshal_cleanup_args_return_fail
  77  *    - pygi_marshal_cleanup_args_to_py_parameter_fail
  78  *
  79  **/
  80 void
  81 pygi_marshal_cleanup_args_from_py_marshal_success (PyGIInvokeState   *state,
  82                                                    PyGICallableCache *cache)
  83 {
  84     gssize i;
  85
  86     /* For in success, call cleanup for all GI_DIRECTION_IN values only. */
  87     for (i = 0; i < cache->n_args; i++) {
  88         PyGIArgCache *arg_cache = cache->args_cache[i];
  89         PyGIMarshalCleanupFunc cleanup_func = arg_cache->from_py_cleanup;
  90
  91         if (cleanup_func &&
  92                 arg_cache->direction == PYGI_DIRECTION_FROM_PYTHON &&
  93                     state->args[i]->v_pointer != NULL)
  94             cleanup_func (state, arg_cache, state->args[i]->v_pointer, TRUE);
  95     }
  96 }
  97
  98 void
  99 pygi_marshal_cleanup_args_to_py_marshal_success (PyGIInvokeState   *state,
 100                                                  PyGICallableCache *cache)
 101 {
 102     /* clean up the return if available */
 103     if (cache->return_cache != NULL) {
 104         PyGIMarshalCleanupFunc cleanup_func = cache->return_cache->to_py_cleanup;
 105         if (cleanup_func && state->return_arg.v_pointer != NULL)
 106             cleanup_func (state,
 107                           cache->return_cache,
 108                           state->return_arg.v_pointer,
 109                           TRUE);
 110     }
 111
 112     /* Now clean up args */
 113     GSList *cache_item = cache->to_py_args;
 114     while (cache_item) {
 115         PyGIArgCache *arg_cache = (PyGIArgCache *) cache_item->data;
 116         PyGIMarshalCleanupFunc cleanup_func = arg_cache->to_py_cleanup;
 117         gpointer data = state->args[arg_cache->c_arg_index]->v_pointer;
 118
 119         if (cleanup_func != NULL && data != NULL)
 120             cleanup_func (state,
 121                           arg_cache,
 122                           data,
 123                           TRUE);
 124
 125         cache_item = cache_item->next;
 126     }
 127 }
 128
 129 void
 130 pygi_marshal_cleanup_args_from_py_parameter_fail (PyGIInvokeState   *state,
 131                                                   PyGICallableCache *cache,
 132                                                   gssize failed_arg_index)
 133 {
 134     gssize i;
 135
 136     state->failed = TRUE;
 137
 138     for (i = 0; i < cache->n_args  && i <= failed_arg_index; i++) {
 139         PyGIArgCache *arg_cache = cache->args_cache[i];
 140         PyGIMarshalCleanupFunc cleanup_func = arg_cache->from_py_cleanup;
 141         gpointer data = state->args[i]->v_pointer;
 142
 143         if (cleanup_func &&
 144                 arg_cache->direction == PYGI_DIRECTION_FROM_PYTHON &&
 145                     data != NULL) {
 146             cleanup_func (state,
 147                           arg_cache,
 148                           data,
 149                           i < failed_arg_index);
 150
 151         } else if (arg_cache->is_caller_allocates && data != NULL) {
 152             _cleanup_caller_allocates (state,
 153                                        arg_cache,
 154                                        data);
 155         }
 156     }
 157 }
 158
 159 void
 160 pygi_marshal_cleanup_args_return_fail (PyGIInvokeState   *state,
 161                                        PyGICallableCache *cache)
 162 {
 163     state->failed = TRUE;
 164 }
 165
 166 void
 167 pygi_marshal_cleanup_args_to_py_parameter_fail (PyGIInvokeState   *state,
 168                                               PyGICallableCache *cache,
 169                                               gssize failed_to_py_arg_index)
 170 {
 171     state->failed = TRUE;
 172 }
 173
 174 void
 175 _pygi_marshal_cleanup_from_py_utf8 (PyGIInvokeState *state,
 176                                     PyGIArgCache    *arg_cache,
 177                                     gpointer         data,
 178                                     gboolean         was_processed)
 179 {
 180     /* We strdup strings so always free if we have processed this
 181        parameter for input */
 182     if (was_processed)
 183         g_free (data);
 184 }
 185
 186 void
 187 _pygi_marshal_cleanup_to_py_utf8 (PyGIInvokeState *state,
 188                                   PyGIArgCache    *arg_cache,
 189                                   gpointer         data,
 190                                   gboolean         was_processed)
 191 {
 192     /* Python copies the string so we need to free it
 193        if the interface is transfering ownership,
 194        whether or not it has been processed yet */
 195     if (arg_cache->transfer == GI_TRANSFER_EVERYTHING)
 196         g_free (data);
 197 }
 198
 199 void
 200 _pygi_marshal_cleanup_from_py_interface_object (PyGIInvokeState *state,
 201                                                 PyGIArgCache    *arg_cache,
 202                                                 gpointer         data,
 203                                                 gboolean         was_processed)
 204 {
 205     /* If we processed the parameter but fail before invoking the method,
 206        we need to remove the ref we added */
 207     if (was_processed && state->failed && data != NULL &&
 208             arg_cache->transfer == GI_TRANSFER_EVERYTHING)
 209         g_object_unref (G_OBJECT(data));
 210 }
 211
 212 void
 213 _pygi_marshal_cleanup_to_py_interface_object (PyGIInvokeState *state,
 214                                               PyGIArgCache    *arg_cache,
 215                                               gpointer         data,
 216                                               gboolean         was_processed)
 217 {
 218     /* If we error out and the object is not marshalled into a PyGObject
 219        we must take care of removing the ref */
 220     if (!was_processed && arg_cache->transfer == GI_TRANSFER_EVERYTHING)
 221         g_object_unref (G_OBJECT(data));
 222 }
 223
 224 void
 225 _pygi_marshal_cleanup_from_py_interface_struct_gvalue (PyGIInvokeState *state,
 226                                                        PyGIArgCache    *arg_cache,
 227                                                        gpointer         data,
 228                                                        gboolean         was_processed)
 229 {
 230     if (was_processed) {
 231         PyObject *py_arg = PyTuple_GET_ITEM (state->py_in_args,
 232                                              arg_cache->py_arg_index);
 233         GType py_object_type =
 234             pyg_type_from_object_strict ( (PyObject *) py_arg->ob_type, FALSE);
 235
 236         if (py_object_type != G_TYPE_VALUE) {
 237             g_value_unset ((GValue *) data);
 238             g_slice_free (GValue, data);
 239         }
 240     }
 241 }
 242
 243 void
 244 _pygi_marshal_cleanup_from_py_interface_struct_foreign (PyGIInvokeState *state,
 245                                                         PyGIArgCache    *arg_cache,
 246                                                         gpointer         data,
 247                                                         gboolean         was_processed)
 248 {
 249     if (state->failed && was_processed)
 250         pygi_struct_foreign_release (
 251             ( (PyGIInterfaceCache *)arg_cache)->interface_info,
 252             data);
 253 }
 254
 255 void
 256 _pygi_marshal_cleanup_to_py_interface_struct_foreign (PyGIInvokeState *state,
 257                                                       PyGIArgCache    *arg_cache,
 258                                                       gpointer         data,
 259                                                       gboolean         was_processed)
 260 {
 261     if (!was_processed && arg_cache->transfer == GI_TRANSFER_EVERYTHING)
 262         pygi_struct_foreign_release (
 263             ( (PyGIInterfaceCache *)arg_cache)->interface_info,
 264             data);
 265 }
 266
 267 static GArray*
 268 _wrap_c_array (PyGIInvokeState   *state,
 269                PyGISequenceCache *sequence_cache,
 270                gpointer           data)
 271 {
 272     GArray *array_;
 273     gsize   len = 0;
 274
 275     if (sequence_cache->fixed_size >= 0) {
 276         len = sequence_cache->fixed_size;
 277     } else if (sequence_cache->is_zero_terminated) {
 278         len = g_strv_length ((gchar **)data);
 279     } else if (sequence_cache->len_arg_index >= 0) {
 280         GIArgument *len_arg = state->args[sequence_cache->len_arg_index];
 281         len = len_arg->v_long;
 282     }
 283
 284     array_ = g_array_new (FALSE,
 285                           FALSE,
 286                           sequence_cache->item_size);
 287
 288     if (array_ == NULL)
 289         return NULL;
 290
 291     g_free (array_->data);
 292     array_->data = data;
 293     array_->len = len;
 294
 295     return array_;
 296 }
 297
 298 void
 299 _pygi_marshal_cleanup_from_py_array (PyGIInvokeState *state,
 300                                      PyGIArgCache    *arg_cache,
 301                                      gpointer         data,
 302                                      gboolean         was_processed)
 303 {
 304     if (was_processed) {
 305         GArray *array_ = NULL;
 306         GPtrArray *ptr_array_ = NULL;
 307         PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
 308
 309         /* If this isn't a garray create one to help process variable sized
 310            array elements */
 311         if (sequence_cache->array_type == GI_ARRAY_TYPE_C) {
 312             array_ = _wrap_c_array (state, sequence_cache, data);
 313
 314             if (array_ == NULL)
 315                 return;
 316
 317         } else if (sequence_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
 318             ptr_array_ = (GPtrArray *) data;
 319         } else {
 320             array_ = (GArray *) data;
 321         }
 322
 323         /* clean up items first */
 324         if (sequence_cache->item_cache->from_py_cleanup != NULL) {
 325             gsize i;
 326             guint len = (array_ != NULL) ? array_->len : ptr_array_->len;
 327             PyGIMarshalCleanupFunc cleanup_func =
 328                 sequence_cache->item_cache->from_py_cleanup;
 329
 330             for (i = 0; i < len; i++) {
 331                 gpointer item;
 332
 333                 /* case 1: GPtrArray */
 334                 if (ptr_array_ != NULL)
 335                     item = g_ptr_array_index (ptr_array_, i);
 336                 /* case 2: C array or GArray with object pointers */
 337                 else if (sequence_cache->item_cache->is_pointer)
 338                     item = g_array_index (array_, gpointer, i);
 339                 /* case 3: C array or GArray with simple types or structs */
 340                 else
 341                     item = array_->data + i * sequence_cache->item_size;
 342
 343                 cleanup_func (state, sequence_cache->item_cache, item, TRUE);
 344             }
 345         }
 346
 347         /* Only free the array when we didn't transfer ownership */
 348         if (sequence_cache->array_type == GI_ARRAY_TYPE_C) {
 349             g_array_free (array_, arg_cache->transfer == GI_TRANSFER_NOTHING);
 350         } else if (state->failed ||
 351                    arg_cache->transfer == GI_TRANSFER_NOTHING) {
 352             if (array_ != NULL)
 353                 g_array_free (array_, TRUE);
 354             else
 355                 g_ptr_array_free (ptr_array_, TRUE);
 356         }
 357     }
 358 }
 359
 360 void
 361 _pygi_marshal_cleanup_to_py_array (PyGIInvokeState *state,
 362                                    PyGIArgCache    *arg_cache,
 363                                    gpointer         data,
 364                                    gboolean         was_processed)
 365 {
 366     if (arg_cache->transfer == GI_TRANSFER_EVERYTHING ||
 367         arg_cache->transfer == GI_TRANSFER_CONTAINER) {
 368         GArray *array_ = NULL;
 369         GPtrArray *ptr_array_ = NULL;
 370         PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
 371
 372         /* If this isn't a garray create one to help process variable sized
 373            array elements */
 374         if (sequence_cache->array_type == GI_ARRAY_TYPE_C) {
 375             array_ = _wrap_c_array (state, sequence_cache, data);
 376
 377             if (array_ == NULL)
 378                 return;
 379
 380         } else if (sequence_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
 381             ptr_array_ = (GPtrArray *) data;
 382         } else {
 383             array_ = (GArray *) data;
 384         }
 385
 386         if (sequence_cache->item_cache->to_py_cleanup != NULL) {
 387             gsize i;
 388             guint len = (array_ != NULL) ? array_->len : ptr_array_->len;
 389
 390             PyGIMarshalCleanupFunc cleanup_func = sequence_cache->item_cache->to_py_cleanup;
 391             for (i = 0; i < len; i++) {
 392                 cleanup_func (state,
 393                               sequence_cache->item_cache,
 394                               (array_ != NULL) ? g_array_index (array_, gpointer, i) : g_ptr_array_index (ptr_array_, i),
 395                               was_processed);
 396             }
 397         }
 398
 399         if (array_ != NULL)
 400             g_array_free (array_, TRUE);
 401         else
 402             g_ptr_array_free (ptr_array_, TRUE);
 403     }
 404 }
 405
 406 void
 407 _pygi_marshal_cleanup_from_py_glist  (PyGIInvokeState *state,
 408                                       PyGIArgCache    *arg_cache,
 409                                       gpointer         data,
 410                                       gboolean         was_processed)
 411 {
 412     if (was_processed) {
 413         GSList *list_;
 414         PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
 415
 416         list_ = (GSList *)data;
 417
 418         /* clean up items first */
 419         if (sequence_cache->item_cache->from_py_cleanup != NULL) {
 420             PyGIMarshalCleanupFunc cleanup_func =
 421                 sequence_cache->item_cache->from_py_cleanup;
 422             GSList *node = list_;
 423             while (node != NULL) {
 424                 cleanup_func (state,
 425                               sequence_cache->item_cache,
 426                               node->data,
 427                               TRUE);
 428                 node = node->next;
 429             }
 430         }
 431
 432         if (state->failed ||
 433                arg_cache->transfer == GI_TRANSFER_NOTHING ||
 434                   arg_cache->transfer == GI_TRANSFER_CONTAINER) {
 435             switch (arg_cache->type_tag) {
 436                 case GI_TYPE_TAG_GLIST:
 437                     g_list_free ( (GList *)list_);
 438                     break;
 439                 case GI_TYPE_TAG_GSLIST:
 440                     g_slist_free (list_);
 441                     break;
 442                 default:
 443                     g_assert_not_reached();
 444             }
 445         }
 446     }
 447 }
 448
 449 void
 450 _pygi_marshal_cleanup_to_py_glist (PyGIInvokeState *state,
 451                                    PyGIArgCache    *arg_cache,
 452                                    gpointer         data,
 453                                    gboolean         was_processed)
 454 {
 455     PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
 456
 457     if (arg_cache->transfer == GI_TRANSFER_EVERYTHING ||
 458             arg_cache->transfer == GI_TRANSFER_CONTAINER) {
 459         GSList *list_ = (GSList *)data;
 460
 461         if (sequence_cache->item_cache->to_py_cleanup != NULL) {
 462             PyGIMarshalCleanupFunc cleanup_func =
 463                 sequence_cache->item_cache->to_py_cleanup;
 464             GSList *node = list_;
 465
 466             while (node != NULL) {
 467                 cleanup_func (state,
 468                               sequence_cache->item_cache,
 469                               node->data,
 470                               was_processed);
 471                 node = node->next;
 472             }
 473         }
 474
 475         if (arg_cache->transfer == GI_TRANSFER_EVERYTHING) {
 476             switch (arg_cache->type_tag) {
 477                 case GI_TYPE_TAG_GLIST:
 478                     g_list_free ( (GList *)list_);
 479                     break;
 480                 case GI_TYPE_TAG_GSLIST:
 481                     g_slist_free (list_);
 482                     break;
 483                 default:
 484                     g_assert_not_reached();
 485             }
 486         }
 487     }
 488 }
 489
 490 void
 491 _pygi_marshal_cleanup_from_py_ghash  (PyGIInvokeState *state,
 492                                       PyGIArgCache    *arg_cache,
 493                                       gpointer         data,
 494                                       gboolean         was_processed)
 495 {
 496     if (data == NULL)
 497         return;
 498
 499     if (was_processed) {
 500         GHashTable *hash_;
 501         PyGIHashCache *hash_cache = (PyGIHashCache *)arg_cache;
 502
 503         hash_ = (GHashTable *)data;
 504
 505         /* clean up keys and values first */
 506         if (hash_cache->key_cache->from_py_cleanup != NULL ||
 507                 hash_cache->value_cache->from_py_cleanup != NULL) {
 508             GHashTableIter hiter;
 509             gpointer key;
 510             gpointer value;
 511
 512             PyGIMarshalCleanupFunc key_cleanup_func =
 513                 hash_cache->key_cache->from_py_cleanup;
 514             PyGIMarshalCleanupFunc value_cleanup_func =
 515                 hash_cache->value_cache->from_py_cleanup;
 516
 517             g_hash_table_iter_init (&hiter, hash_);
 518             while (g_hash_table_iter_next (&hiter, &key, &value)) {
 519                 if (key != NULL && key_cleanup_func != NULL)
 520                     key_cleanup_func (state,
 521                                       hash_cache->key_cache,
 522                                       key,
 523                                       TRUE);
 524                 if (value != NULL && value_cleanup_func != NULL)
 525                     value_cleanup_func (state,
 526                                         hash_cache->value_cache,
 527                                         value,
 528                                         TRUE);
 529             }
 530         }
 531
 532         if (state->failed ||
 533                arg_cache->transfer == GI_TRANSFER_NOTHING ||
 534                   arg_cache->transfer == GI_TRANSFER_CONTAINER)
 535             g_hash_table_destroy (hash_);
 536
 537     }
 538 }
 539
 540 void
 541 _pygi_marshal_cleanup_to_py_ghash (PyGIInvokeState *state,
 542                                    PyGIArgCache    *arg_cache,
 543                                    gpointer         data,
 544                                    gboolean         was_processed)
 545 {
 546     if (data == NULL)
 547         return;
 548
 549     /* assume hashtable has boxed key and value */
 550     if (arg_cache->transfer == GI_TRANSFER_EVERYTHING)
 551         g_hash_table_destroy ( (GHashTable *)data);
 552 }