camel/camel-folder-pt-proxy.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /* camel-folder-pt-proxy.c : proxy folder using posix threads */
   3
   4 /*
   5  *
   6  * Copyright (C) 1999 Bertrand Guiheneuf <Bertrand.Guiheneuf@aful.org> .
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21  * USA
  22  */
  23
  24 /* FIXME :
  25  *
  26  * the current implementation lauches requests
  27  * on the real folder without bothering on wether
  28  * the global mutex (folder->mutex) is locked or
  29  * not.
  30  * This means that you could have 100 threads
  31  * waiting for the mutex at the same time.
  32  * This is not really a bug, more a nasty feature ;)
  33  *
  34  * This will be solved when the CORBA proxy is
  35  * written, as we will need to queue the requests
  36  * on the client side. The same queue mechanism
  37  * will be used for the pthread proxy
  38  *
  39  */
  40
  41
  42
  43 #include <config.h>
  44 #include "camel-folder-pt-proxy.h"
  45 #include "camel-log.h"
  46 #include <pthread.h>
  47 #include <unistd.h>
  48 #include <string.h>
  49 #include <errno.h>
  50
  51 /* needed for proper casts of async funcs when
  52  * calling pthreads_create
  53  */
  54 typedef void * (*thread_call_func) (void *);
  55
  56 static CamelFolderClass *parent_class=NULL;
  57
  58 /* Returns the class for CamelFolderPtProxy and CamelFolder objects */
  59 #define CFPP_CLASS(so) CAMEL_FOLDER_PT_PROXY_CLASS (GTK_OBJECT(so)->klass)
  60 #define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass)
  61
  62 static void _init_with_store (CamelFolder *folder, CamelStore *parent_store);
  63 static void _open (CamelFolder *folder, CamelFolderOpenMode mode);
  64 static void _close (CamelFolder *folder, gboolean expunge);
  65 static void _set_name (CamelFolder *folder, const gchar *name);
  66 static const gchar *_get_name (CamelFolder *folder);
  67 static const gchar *_get_full_name (CamelFolder *folder);
  68 static gboolean _can_hold_folders (CamelFolder *folder);
  69 static gboolean _can_hold_messages(CamelFolder *folder);
  70 static gboolean _exists (CamelFolder  *folder);
  71 static gboolean _is_open (CamelFolder *folder);
  72 static CamelFolder *_get_folder (CamelFolder *folder, const gchar *folder_name);
  73 static gboolean _create (CamelFolder *folder);
  74 static gboolean _delete (CamelFolder *folder, gboolean recurse);
  75 static gboolean _delete_messages (CamelFolder *folder);
  76 static CamelFolder *_get_parent_folder (CamelFolder *folder);
  77 static CamelStore *_get_parent_store (CamelFolder *folder);
  78 static CamelFolderOpenMode _get_mode (CamelFolder *folder);
  79 static GList *_list_subfolders (CamelFolder *folder);
  80 static void _expunge (CamelFolder *folder);
  81 static CamelMimeMessage *_get_message (CamelFolder *folder, gint number);
  82 static gint _get_message_count (CamelFolder *folder);
  83 static gint _append_message (CamelFolder *folder, CamelMimeMessage *message);
  84 static const GList *_list_permanent_flags (CamelFolder *folder);
  85 static void _copy_message_to (CamelFolder *folder, CamelMimeMessage *message, CamelFolder *dest_folder);
  86
  87 static const gchar *_get_message_uid (CamelFolder *folder, CamelMimeMessage *message);
  88 static CamelMimeMessage *_get_message_by_uid (CamelFolder *folder, const gchar *uid);
  89 static GList *_get_uid_list  (CamelFolder *folder);
  90
  91
  92 static void _finalize (GtkObject *object);
  93
  94
  95 static void
  96 camel_folder_proxy_class_init (CamelFolderPtProxyClass *camel_folder_pt_proxy_class)
  97 {
  98         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (camel_folder_pt_proxy_class);
  99         CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_folder_pt_proxy_class);
 100
 101         parent_class = gtk_type_class (camel_folder_get_type ());
 102
 103         /* virtual method definition */
 104         camel_folder_class->init_with_store = _init_with_store;
 105         camel_folder_class->open = _open;
 106         camel_folder_class->close = _close;
 107         camel_folder_class->set_name = _set_name;
 108         camel_folder_class->get_name = _get_name;
 109         camel_folder_class->can_hold_folders = _can_hold_folders;
 110         camel_folder_class->can_hold_messages = _can_hold_messages;
 111         camel_folder_class->exists = _exists;
 112         camel_folder_class->is_open = _is_open;
 113         camel_folder_class->get_folder = _get_folder;
 114         camel_folder_class->create = _create;
 115         camel_folder_class->delete = _delete;
 116         camel_folder_class->delete_messages = _delete_messages;
 117         camel_folder_class->get_parent_folder = _get_parent_folder;
 118         camel_folder_class->get_parent_store = _get_parent_store;
 119         camel_folder_class->get_mode = _get_mode;
 120         camel_folder_class->list_subfolders = _list_subfolders;
 121         camel_folder_class->expunge = _expunge;
 122         camel_folder_class->get_message = _get_message;
 123         camel_folder_class->get_message_count = _get_message_count;
 124         camel_folder_class->append_message = _append_message;
 125         camel_folder_class->list_permanent_flags = _list_permanent_flags;
 126         camel_folder_class->copy_message_to;
 127         camel_folder_class->get_message_uid = _get_message_uid;
 128         camel_folder_class->get_message_by_uid = _get_message_by_uid;
 129         camel_folder_class->get_uid_list = _get_uid_list;
 130
 131         /* virtual method overload */
 132         gtk_object_class->finalize = _finalize;
 133 }
 134
 135
 136
 137
 138 static void
 139 camel_folder_proxy_init (CamelFolderPtProxy *folder_pt_proxy)
 140 {
 141
 142
 143         folder_pt_proxy->op_queue = camel_op_queue_new ();
 144
 145 }
 146
 147
 148
 149 GtkType
 150 camel_folder_proxy_get_type (void)
 151 {
 152         static GtkType camel_folder_pt_proxy_type = 0;
 153
 154         if (!camel_folder_pt_proxy_type)        {
 155                 GtkTypeInfo camel_folder_pt_proxy_info =
 156                 {
 157                         "CamelFolderPtProxy",
 158                         sizeof (CamelFolderPtProxy),
 159                         sizeof (CamelFolderPtProxyClass),
 160                         (GtkClassInitFunc) camel_folder_proxy_class_init,
 161                         (GtkObjectInitFunc) camel_folder_proxy_init,
 162                                 /* reserved_1 */ NULL,
 163                                 /* reserved_2 */ NULL,
 164                         (GtkClassInitFunc) NULL,
 165                 };
 166
 167                 camel_folder_pt_proxy_type = gtk_type_unique (gtk_object_get_type (), &camel_folder_pt_proxy_info);
 168         }
 169
 170         return camel_folder_pt_proxy_type;
 171 }
 172
 173
 174 static void
 175 _finalize (GtkObject *object)
 176 {
 177         CamelFolder *camel_folder = CAMEL_FOLDER (object);
 178         GList *message_node;
 179
 180         CAMEL_LOG_FULL_DEBUG ("Entering CamelFolderPtProxy::finalize\n");
 181
 182
 183         GTK_OBJECT_CLASS (parent_class)->finalize (object);
 184         CAMEL_LOG_FULL_DEBUG ("Leaving CamelFolderPtProxy::finalize\n");
 185 }
 186
 187
 188
 189 static void
 190 _plan_op_for_exec (CamelOp *op)
 191 {
 192
 193
 194 }
 195
 196
 197 /* folder->init_with_store implementation */
 198
 199 typedef struct {
 200         CamelFolder *folder;
 201         CamelStore *parent_store;
 202 } _InitStoreParam;
 203
 204 static void
 205 _async_init_with_store (_InitStoreParam *param)
 206 {
 207         CamelFolder *folder = param->folder;
 208         CamelFolderPtProxy *proxy_folder;
 209         CamelFolder *real_folder;
 210
 211         proxy_folder = CAMEL_FOLDER_PT_PROXY (folder);
 212         real_folder = proxy_folder->real_folder;
 213
 214         /* we may block here but we are actually in a
 215          * separate thread, so no problem
 216          */
 217         g_static_mutex_lock (&(proxy_folder->mutex));
 218
 219         CF_CLASS (real_folder)->init_with_store (real_folder, param->parent_store);
 220         g_free (param);
 221         g_static_mutex_unlock (&(proxy_folder->mutex));
 222 }
 223
 224
 225 static void
 226 _init_with_store (CamelFolder *folder, CamelStore *parent_store)
 227 {
 228         CamelFolderPtProxy *proxy_folder = CAMEL_FOLDER_PT_PROXY (folder);
 229         _InitStoreParam *param;
 230         pthread_t init_store_thread;
 231         int filedes[2];
 232
 233 #warning Notify io_channel initialization should be elsewhere
 234         /* it can not be in camel_folder_proxy_init
 235          * because of the pipe error handling */
 236
 237         /* set up the notification channel */
 238         if (!pipe (filedes)) {
 239                 CAMEL_LOG_WARNING ("could not create pipe in for camel_folder_proxy_init");
 240                 CAMEL_LOG_FULL_DEBUG ("Full error message : %s\n", strerror(errno));
 241                 return;
 242         }
 243
 244         proxy_folder->pipe_client_fd = filedes [0];
 245         proxy_folder->pipe_server_fd = filedes [1];
 246         proxy_folder->notify_source =  g_io_channel_unix_new (filedes [0]);
 247
 248         /* param will be freed in _async_init_with_store */
 249         param = g_new (_InitStoreParam, 1);
 250         param->folder = folder;
 251         param->parent_store = parent_store;
 252
 253         /*
 254          * call _async_init_with_store in a separate thread
 255          * the thread may block on a mutex, but not the main
 256          * thread.
 257          */
 258         pthread_create (&init_store_thread, NULL , (thread_call_func)_async_init_with_store, param);
 259
 260 }
 261
 262
 263
 264
 265 /* folder->open implementation */
 266 typedef struct {
 267         CamelFolder *folder;
 268         CamelFolderOpenMode mode;
 269 } _openFolderParam;
 270
 271 static void
 272 _open (CamelFolder *folder, CamelFolderOpenMode mode)
 273 {
 274
 275 }
 276
 277
 278
 279
 280 static void
 281 _close (CamelFolder *folder, gboolean expunge)
 282 {
 283         if (expunge) camel_folder_expunge (folder, FALSE);
 284         folder->open_state = FOLDER_CLOSE;
 285 }
 286
 287
 288
 289
 290 static void
 291 _set_name (CamelFolder *folder, const gchar *name)
 292 {
 293
 294 }
 295
 296
 297
 298 static const gchar *
 299 _get_name (CamelFolder *folder)
 300 {
 301         return folder->name;
 302 }
 303
 304
 305
 306
 307 static const gchar *
 308 _get_full_name (CamelFolder *folder)
 309 {
 310         return folder->full_name;
 311 }
 312
 313
 314
 315
 316 static gboolean
 317 _can_hold_folders (CamelFolder *folder)
 318 {
 319         return folder->can_hold_folders;
 320 }
 321
 322
 323
 324
 325 static gboolean
 326 _can_hold_messages (CamelFolder *folder)
 327 {
 328         return folder->can_hold_messages;
 329 }
 330
 331
 332
 333 static gboolean
 334 _exists (CamelFolder *folder)
 335 {
 336         return FALSE;
 337 }
 338
 339
 340
 341
 342 static gboolean
 343 _is_open (CamelFolder *folder)
 344 {
 345         return (folder->open_state == FOLDER_OPEN);
 346 }
 347
 348
 349
 350
 351
 352 static CamelFolder *
 353 _get_folder (CamelFolder *folder, const gchar *folder_name)
 354 {
 355
 356         return NULL;
 357 }
 358
 359
 360
 361
 362
 363
 364 static gboolean
 365 _create(CamelFolder *folder)
 366 {
 367
 368         return FALSE;
 369 }
 370
 371
 372
 373
 374
 375
 376
 377
 378 static gboolean
 379 _delete (CamelFolder *folder, gboolean recurse)
 380 {
 381         return FALSE;
 382 }
 383
 384
 385
 386
 387
 388
 389
 390 static gboolean
 391 _delete_messages (CamelFolder *folder)
 392 {
 393         return TRUE;
 394 }
 395
 396
 397
 398
 399
 400
 401 static CamelFolder *
 402 _get_parent_folder (CamelFolder *folder)
 403 {
 404         return folder->parent_folder;
 405 }
 406
 407
 408
 409
 410
 411 static CamelStore *
 412 _get_parent_store (CamelFolder *folder)
 413 {
 414         return folder->parent_store;
 415 }
 416
 417
 418
 419
 420 static CamelFolderOpenMode
 421 _get_mode (CamelFolder *folder)
 422 {
 423         return folder->open_mode;
 424 }
 425
 426
 427
 428
 429 static GList *
 430 _list_subfolders (CamelFolder *folder)
 431 {
 432         return NULL;
 433 }
 434
 435
 436
 437
 438 static void
 439 _expunge (CamelFolder *folder)
 440 {
 441
 442 }
 443
 444
 445
 446
 447 static CamelMimeMessage *
 448 _get_message (CamelFolder *folder, gint number)
 449 {
 450         return NULL;
 451 }
 452
 453
 454
 455
 456
 457 static gint
 458 _get_message_count (CamelFolder *folder)
 459 {
 460         return -1;
 461 }
 462
 463
 464
 465
 466 static gint
 467 _append_message (CamelFolder *folder, CamelMimeMessage *message)
 468 {
 469         return -1;
 470 }
 471
 472
 473
 474 static const GList *
 475 _list_permanent_flags (CamelFolder *folder)
 476 {
 477         return folder->permanent_flags;
 478 }
 479
 480
 481
 482 static void
 483 _copy_message_to (CamelFolder *folder, CamelMimeMessage *message, CamelFolder *dest_folder)
 484 {
 485         camel_folder_append_message (dest_folder, message);
 486 }
 487
 488
 489
 490
 491
 492
 493 /* UIDs stuff */
 494
 495
 496 static const gchar *
 497 _get_message_uid (CamelFolder *folder, CamelMimeMessage *message)
 498 {
 499         return NULL;
 500 }
 501
 502
 503 /* the next two func are left there temporarily */
 504 static const gchar *
 505 _get_message_uid_by_number (CamelFolder *folder, gint message_number)
 506 {
 507         return NULL;
 508 }
 509
 510
 511
 512 static CamelMimeMessage *
 513 _get_message_by_uid (CamelFolder *folder, const gchar *uid)
 514 {
 515         return NULL;
 516 }
 517
 518
 519 static GList *
 520 _get_uid_list  (CamelFolder *folder)
 521 {
 522         return NULL;
 523 }
 524
 525
 526 /* **** */