Changeset 3573

Show
Ignore:
Timestamp:
08/21/08 18:41:15 (3 months ago)
Author:
bellmich
Message:

centralize the transport init

Location:
plugins/syncml/src
Files:
5 modified

Legend:

Unmodified
Added
Removed

  • plugins/syncml/src/syncml_common.c

    r3571 r3573  
    2222#include "syncml_callbacks.h" 
    2323#include "syncml_devinf.h" 
     24#include "syncml_vformat.h" 
    2425 
    2526#include <opensync/plugin/opensync_sink.h> 
    … …  
    627628} 
    628629 
     630void *syncml_init( 
     631                SmlSessionType sessionType, 
     632                SmlTransportType tspType, 
     633                OSyncPlugin *plugin, 
     634                OSyncPluginInfo *info, 
     635                OSyncError **oerror) 
     636{ 
     637        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, oerror); 
     638        SmlError *error = NULL; 
     639         
     640        SmlPluginEnv *env = osync_try_malloc0(sizeof(SmlPluginEnv), oerror); 
     641        if (!env) 
     642                goto error; 
     643        env->sessionType = sessionType; 
     644        env->pluginInfo = info; 
     645        osync_plugin_info_ref(env->pluginInfo); 
     646 
     647        OSyncPluginConfig *config = osync_plugin_info_get_config(info); 
     648        osync_trace(TRACE_INTERNAL, "The config: %p", config); 
     649 
     650        /* create data sync object */ 
     651        env->dsObject1 = smlDataSyncNew(sessionType, tspType, &error); 
     652        if (!env->dsObject1) 
     653                goto error; 
     654        if (sessionType == SML_SESSION_TYPE_CLIENT) 
     655        { 
     656                env->dsObject2 = smlDataSyncNew(sessionType, tspType, &error); 
     657                if (!env->dsObject2) 
     658                        goto error; 
     659        } 
     660 
     661        /* configure the instance */ 
     662        if (!parse_config(tspType, env->dsObject1, config, oerror)) 
     663                goto error_free_env; 
     664        if (sessionType == SML_SESSION_TYPE_CLIENT) 
     665        { 
     666                if (!parse_config(tspType, env->dsObject2, config, oerror)) 
     667                        goto error_free_env; 
     668        } 
     669 
     670        /* prepare the function list for OpenSync */ 
     671        OSyncObjTypeSinkFunctions main_functions; 
     672        memset(&main_functions, 0, sizeof(main_functions)); 
     673        main_functions.connect = syncml_connect; 
     674        main_functions.disconnect = disconnect; 
     675 
     676        /* Register main sink for connect and disconnect functions */ 
     677        OSyncObjTypeSink *mainsink = osync_objtype_main_sink_new(oerror); 
     678        if (!mainsink) 
     679                goto error_free_env; 
     680 
     681        osync_objtype_sink_set_functions(mainsink, main_functions, env); 
     682        osync_plugin_info_set_main_sink(info, mainsink); 
     683        osync_objtype_sink_unref(mainsink); 
     684 
     685        /* prepare paths for callbacks */ 
     686        env->anchor_path = g_strdup_printf("%s/anchor.db", osync_plugin_info_get_configdir(info)); 
     687        env->devinf_path = g_strdup_printf("%s/devinf.db", osync_plugin_info_get_configdir(info)); 
     688 
     689        /* set callbacks */ 
     690        smlDataSyncRegisterEventCallback(env->dsObject1, _recv_event, env); 
     691        smlDataSyncRegisterGetAlertTypeCallback(env->dsObject1, _get_alert_type, env); 
     692        smlDataSyncRegisterGetAnchorCallback(env->dsObject1, _get_anchor, env); 
     693        smlDataSyncRegisterSetAnchorCallback(env->dsObject1, _set_anchor, env); 
     694        smlDataSyncRegisterWriteDevInfCallback(env->dsObject1, _write_devinf, env); 
     695        smlDataSyncRegisterReadDevInfCallback(env->dsObject1, _read_devinf, env); 
     696        smlDataSyncRegisterHandleRemoteDevInfCallback(env->dsObject1, _handle_remote_devinf, env); 
     697        smlDataSyncRegisterChangeStatusCallback(env->dsObject1, _recv_change_status); 
     698        if (sessionType == SML_SESSION_TYPE_CLIENT) 
     699        { 
     700                smlDataSyncRegisterEventCallback(env->dsObject2, _recv_event, env); 
     701                smlDataSyncRegisterGetAlertTypeCallback(env->dsObject2, _get_alert_type, env); 
     702                smlDataSyncRegisterGetAnchorCallback(env->dsObject2, _get_anchor, env); 
     703                smlDataSyncRegisterSetAnchorCallback(env->dsObject2, _set_anchor, env); 
     704                smlDataSyncRegisterWriteDevInfCallback(env->dsObject2, _write_devinf, env); 
     705                smlDataSyncRegisterReadDevInfCallback(env->dsObject2, _read_devinf, env); 
     706                smlDataSyncRegisterHandleRemoteDevInfCallback(env->dsObject2, _handle_remote_devinf, env); 
     707                smlDataSyncRegisterChangeStatusCallback(env->dsObject2, _recv_change_status); 
     708        } 
     709 
     710        /* configure databases */ 
     711        if (sessionType == SML_SESSION_TYPE_SERVER && 
     712            !ds_server_init_databases(env, info, oerror)) 
     713                goto error_free_env; 
     714        if (sessionType == SML_SESSION_TYPE_CLIENT && 
     715            !ds_client_init_databases(env, info, oerror)) 
     716                goto error_free_env; 
     717 
     718        osync_trace(TRACE_EXIT, "%s: %p", __func__, env); 
     719        return (void *)env; 
     720 
     721error_free_env: 
     722        finalize(env); 
     723error: 
     724        if (error) { 
     725                osync_error_set(oerror, OSYNC_ERROR_GENERIC, "%s", smlErrorPrint(&error)); 
     726                smlErrorDeref(&error); 
     727        } 
     728        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(oerror)); 
     729        return NULL; 
     730} 
     731 

  • plugins/syncml/src/syncml_common.h

    r3571 r3573  
    146146}; 
    147147 
    148 void sync_done(void *data, OSyncPluginInfo *info, OSyncContext *ctx); 
    149  
    150 void disconnect(void *data, OSyncPluginInfo *info, OSyncContext *ctx); 
    151 void syncml_connect(void *data, OSyncPluginInfo *info, OSyncContext *ctx); 
    152148osync_bool discover( 
    153149                const char *name, 
    … …  
    155151                OSyncPluginInfo *info, 
    156152                OSyncError **error); 
     153void *syncml_init( 
     154                SmlSessionType sessionType, 
     155                SmlTransportType tspType, 
     156                OSyncPlugin *plugin, 
     157                OSyncPluginInfo *info, 
     158                OSyncError **oerror); 
     159void syncml_connect(void *data, OSyncPluginInfo *info, OSyncContext *ctx); 
     160void sync_done(void *data, OSyncPluginInfo *info, OSyncContext *ctx); 
     161void disconnect(void *data, OSyncPluginInfo *info, OSyncContext *ctx); 
    157162 
    158163osync_bool parse_config( 

  • plugins/syncml/src/syncml_http_client.c

    r3571 r3573  
    11#include "syncml_common.h" 
    2 #include "syncml_callbacks.h" 
    3 #include "syncml_devinf.h" 
    4 #include "syncml_ds_client.h" 
    5 #include "syncml_vformat.h" 
    6  
    7 #include <opensync/plugin/opensync_sink.h> 
    82 
    93/* Some informations about the SyncML protocol 
    … …  
    5448{ 
    5549        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, oerror); 
    56         SmlError *error = NULL; 
    57          
    58         SmlPluginEnv *env = osync_try_malloc0(sizeof(SmlPluginEnv), oerror); 
     50 
     51        SmlPluginEnv *env = syncml_init( 
     52                                SML_SESSION_TYPE_CLIENT, 
     53                                SML_TRANSPORT_HTTP_CLIENT, 
     54                                plugin, info, oerror); 
    5955        if (!env) 
    6056                goto error; 
    61         env->sessionType = SML_SESSION_TYPE_CLIENT; 
    62         env->pluginInfo = info; 
    63         osync_plugin_info_ref(env->pluginInfo); 
    6457 
    65         OSyncPluginConfig *config = osync_plugin_info_get_config(info); 
    66         osync_trace(TRACE_INTERNAL, "The config: %p", config); 
    67  
    68         /* create data sync object */ 
    69         env->dsObject1 = smlDataSyncNew( 
    70                                 SML_SESSION_TYPE_CLIENT, 
    71                                 SML_TRANSPORT_HTTP_CLIENT, 
    72                                 &error); 
    73         if (!env->dsObject1) 
    74                 goto error; 
    75         env->dsObject2 = smlDataSyncNew( 
    76                                 SML_SESSION_TYPE_CLIENT, 
    77                                 SML_TRANSPORT_HTTP_CLIENT, 
    78                                 &error); 
    79         if (!env->dsObject2) 
    80                 goto error; 
    81  
    82         /* configure the instance */ 
    83         if (!parse_config(SML_TRANSPORT_HTTP_CLIENT, env->dsObject1, config, oerror)) 
    84                 goto error_free_env; 
    85         if (!parse_config(SML_TRANSPORT_HTTP_CLIENT, env->dsObject2, config, oerror)) 
    86                 goto error_free_env; 
    87  
    88         /* prepare the function list for OpenSync */ 
    89         OSyncObjTypeSinkFunctions main_functions; 
    90         memset(&main_functions, 0, sizeof(main_functions)); 
    91         main_functions.connect = syncml_connect; 
    92         main_functions.disconnect = disconnect; 
    93  
    94         /* Register main sink for connect and disconnect functions */ 
    95         OSyncObjTypeSink *mainsink = osync_objtype_main_sink_new(oerror); 
    96         if (!mainsink) 
    97                 goto error_free_env; 
    98  
    99         osync_objtype_sink_set_functions(mainsink, main_functions, NULL); 
    100         osync_plugin_info_set_main_sink(info, mainsink); 
    101         osync_objtype_sink_unref(mainsink); 
    102  
    103         /* prepare paths for callbacks */ 
    104         env->anchor_path = g_strdup_printf("%s/anchor.db", osync_plugin_info_get_configdir(info)); 
    105         env->devinf_path = g_strdup_printf("%s/devinf.db", osync_plugin_info_get_configdir(info)); 
    106  
    107         /* set callbacks */ 
    108         smlDataSyncRegisterEventCallback(env->dsObject1, _recv_event, env); 
    109         smlDataSyncRegisterGetAlertTypeCallback(env->dsObject1, _get_alert_type, env); 
    110         smlDataSyncRegisterGetAnchorCallback(env->dsObject1, _get_anchor, env); 
    111         smlDataSyncRegisterSetAnchorCallback(env->dsObject1, _set_anchor, env); 
    112         smlDataSyncRegisterWriteDevInfCallback(env->dsObject1, _write_devinf, env); 
    113         smlDataSyncRegisterReadDevInfCallback(env->dsObject1, _read_devinf, env); 
    114         smlDataSyncRegisterHandleRemoteDevInfCallback(env->dsObject1, _handle_remote_devinf, env); 
    115         smlDataSyncRegisterChangeStatusCallback(env->dsObject1, _recv_change_status); 
    116         smlDataSyncRegisterEventCallback(env->dsObject2, _recv_event, env); 
    117         smlDataSyncRegisterGetAlertTypeCallback(env->dsObject2, _get_alert_type, env); 
    118         smlDataSyncRegisterGetAnchorCallback(env->dsObject2, _get_anchor, env); 
    119         smlDataSyncRegisterSetAnchorCallback(env->dsObject2, _set_anchor, env); 
    120         smlDataSyncRegisterWriteDevInfCallback(env->dsObject2, _write_devinf, env); 
    121         smlDataSyncRegisterReadDevInfCallback(env->dsObject2, _read_devinf, env); 
    122         smlDataSyncRegisterHandleRemoteDevInfCallback(env->dsObject2, _handle_remote_devinf, env); 
    123         smlDataSyncRegisterChangeStatusCallback(env->dsObject2, _recv_change_status); 
    124  
    125         /* configure databases */ 
    126         if (!ds_client_init_databases(env, info, oerror)) 
    127                 goto error_free_env; 
    128  
    129         osync_trace(TRACE_EXIT, "%s: %p", __func__, env); 
    130         return (void *)env; 
    131  
    132 error_free_env: 
    133         finalize(env); 
    13458error: 
    135         if (error) { 
    136                 osync_error_set(oerror, OSYNC_ERROR_GENERIC, "%s", smlErrorPrint(&error)); 
    137                 smlErrorDeref(&error); 
    138         } 
    13959        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(oerror)); 
    14060        return NULL; 

  • plugins/syncml/src/syncml_http_server.c

    r3571 r3573  
    2020 
    2121#include "syncml_common.h" 
    22 #include "syncml_callbacks.h" 
    23 #include "syncml_devinf.h" 
    24 #include "syncml_ds_server.h" 
    25 #include "syncml_vformat.h" 
    2622 
    2723void *syncml_http_server_init(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **oerror) 
    2824{ 
    2925        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, oerror); 
    30         SmlError *error = NULL; 
    31          
    32         SmlPluginEnv *env = osync_try_malloc0(sizeof(SmlPluginEnv), oerror); 
     26 
     27        SmlPluginEnv *env = syncml_init( 
     28                                SML_SESSION_TYPE_SERVER, 
     29                                SML_TRANSPORT_HTTP_SERVER, 
     30                                plugin, info, oerror); 
    3331        if (!env) 
    3432                goto error; 
    35         env->sessionType = SML_SESSION_TYPE_SERVER; 
    36         env->pluginInfo = info; 
    37         osync_plugin_info_ref(env->pluginInfo); 
    3833 
    39         OSyncPluginConfig *config = osync_plugin_info_get_config(info); 
    40         osync_trace(TRACE_INTERNAL, "The config: %p", config); 
    41  
    42         /* create data sync object */ 
    43         env->dsObject1 = smlDataSyncNew( 
    44                                 SML_SESSION_TYPE_SERVER, 
    45                                 SML_TRANSPORT_HTTP_SERVER, 
    46                                 &error); 
    47         if (!env->dsObject1) 
    48                 goto error; 
    49  
    50         /* configure the instance */ 
    51         if (!parse_config(SML_TRANSPORT_HTTP_SERVER, env->dsObject1, config, oerror)) 
    52                 goto error_free_env; 
    53  
    54         /* prepare the function list for OpenSync */ 
    55         OSyncObjTypeSinkFunctions main_functions; 
    56         memset(&main_functions, 0, sizeof(main_functions)); 
    57         main_functions.connect = syncml_connect; 
    58         main_functions.disconnect = disconnect; 
    59  
    60         /* Register main sink for connect and disconnect functions */ 
    61         OSyncObjTypeSink *mainsink = osync_objtype_main_sink_new(oerror); 
    62         if (!mainsink) 
    63                 goto error_free_env; 
    64  
    65         osync_objtype_sink_set_functions(mainsink, main_functions, NULL); 
    66         osync_plugin_info_set_main_sink(info, mainsink); 
    67         osync_objtype_sink_unref(mainsink); 
    68  
    69         /* prepare paths for callbacks */ 
    70         env->anchor_path = g_strdup_printf("%s/anchor.db", osync_plugin_info_get_configdir(info)); 
    71         env->devinf_path = g_strdup_printf("%s/devinf.db", osync_plugin_info_get_configdir(info)); 
    72  
    73         /* set callbacks */ 
    74         smlDataSyncRegisterEventCallback(env->dsObject1, _recv_event, env); 
    75         smlDataSyncRegisterGetAlertTypeCallback(env->dsObject1, _get_alert_type, env); 
    76         smlDataSyncRegisterGetAnchorCallback(env->dsObject1, _get_anchor, env); 
    77         smlDataSyncRegisterSetAnchorCallback(env->dsObject1, _set_anchor, env); 
    78         smlDataSyncRegisterWriteDevInfCallback(env->dsObject1, _write_devinf, env); 
    79         smlDataSyncRegisterReadDevInfCallback(env->dsObject1, _read_devinf, env); 
    80         smlDataSyncRegisterHandleRemoteDevInfCallback(env->dsObject1, _handle_remote_devinf, env); 
    81         smlDataSyncRegisterChangeStatusCallback(env->dsObject1, _recv_change_status); 
    82  
    83         /* configure databases */ 
    84         if (!ds_server_init_databases(env, info, oerror)) 
    85                 goto error_free_env; 
    86  
    87         osync_trace(TRACE_EXIT, "%s: %p", __func__, env); 
    88         return (void *)env; 
    89  
    90 error_free_env: 
    91         finalize(env); 
    9234error: 
    93         if (error) { 
    94                 osync_error_set(oerror, OSYNC_ERROR_GENERIC, "%s", smlErrorPrint(&error)); 
    95                 smlErrorDeref(&error); 
    96         } 
    9735        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(oerror)); 
    9836        return NULL; 

  • plugins/syncml/src/syncml_obex_client.c

    r3571 r3573  
    2020 
    2121#include "syncml_common.h" 
    22 #include "syncml_callbacks.h" 
    23 #include "syncml_devinf.h" 
    24 #include "syncml_vformat.h" 
    25 #include "syncml_ds_server.h" 
    26 #include <libsyncml/standard.h> 
    2722 
    2823void *syncml_obex_client_init(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **oerror) 
    2924{ 
    3025        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, oerror); 
    31         SmlError *error = NULL; 
    32          
    33         SmlPluginEnv *env = osync_try_malloc0(sizeof(SmlPluginEnv), oerror); 
     26 
     27        SmlPluginEnv *env = syncml_init( 
     28                                SML_SESSION_TYPE_SERVER, 
     29                                SML_TRANSPORT_OBEX_CLIENT, 
     30                                plugin, info, oerror); 
    3431        if (!env) 
    3532                goto error; 
    36         env->sessionType = SML_SESSION_TYPE_SERVER; 
    37         env->pluginInfo = info; 
    38         osync_plugin_info_ref(env->pluginInfo); 
    39  
    40         OSyncPluginConfig *config = osync_plugin_info_get_config(info); 
    41         osync_trace(TRACE_INTERNAL, "The config: %p", config); 
    42  
    43         /* create data sync object */ 
    44         env->dsObject1 = smlDataSyncNew( 
    45                                 SML_SESSION_TYPE_SERVER, 
    46                                 SML_TRANSPORT_OBEX_CLIENT, 
    47                                 &error); 
    48         if (!env->dsObject1) 
    49                 goto error; 
    50  
    51         /* configure the instance */ 
    52         if (!parse_config(SML_TRANSPORT_OBEX_CLIENT, env->dsObject1, config, oerror)) 
    53                 goto error_free_env; 
    54  
    55         /* prepare the function list for OpenSync */ 
    56         OSyncObjTypeSinkFunctions main_functions; 
    57         memset(&main_functions, 0, sizeof(main_functions)); 
    58         main_functions.connect = syncml_connect; 
    59         main_functions.disconnect = disconnect; 
    60  
    61         /* Register main sink for connect and disconnect functions */ 
    62         OSyncObjTypeSink *mainsink = osync_objtype_main_sink_new(oerror); 
    63         if (!mainsink) 
    64                 goto error_free_env; 
    65  
    66         osync_objtype_sink_set_functions(mainsink, main_functions, env); 
    67         osync_plugin_info_set_main_sink(info, mainsink); 
    68         osync_objtype_sink_unref(mainsink); 
    69  
    70         /* prepare paths for callbacks */ 
    71         env->anchor_path = g_strdup_printf("%s/anchor.db", osync_plugin_info_get_configdir(info)); 
    72         env->devinf_path = g_strdup_printf("%s/devinf.db", osync_plugin_info_get_configdir(info)); 
    73  
    74         /* set callbacks */ 
    75         smlDataSyncRegisterEventCallback(env->dsObject1, _recv_event, env); 
    76         smlDataSyncRegisterGetAlertTypeCallback(env->dsObject1, _get_alert_type, env); 
    77         smlDataSyncRegisterGetAnchorCallback(env->dsObject1, _get_anchor, env); 
    78         smlDataSyncRegisterSetAnchorCallback(env->dsObject1, _set_anchor, env); 
    79         smlDataSyncRegisterWriteDevInfCallback(env->dsObject1, _write_devinf, env); 
    80         smlDataSyncRegisterReadDevInfCallback(env->dsObject1, _read_devinf, env); 
    81         smlDataSyncRegisterHandleRemoteDevInfCallback(env->dsObject1, _handle_remote_devinf, env); 
    82         smlDataSyncRegisterChangeStatusCallback(env->dsObject1, _recv_change_status); 
    83  
    84         /* configure databases */ 
    85         if (!ds_server_init_databases(env, info, oerror)) 
    86                 goto error_free_env; 
    8733 
    8834        /* add the datastores */ 
     35        SmlError *error = NULL; 
    8936        GList *o = env->databases; 
    9037        for (; o; o = o->next) {