--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ofdbus/dbus/tsrc/testapps/method/src/method.c Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,470 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include<stdio.h>
+#include "test-utils.h"
+#include<string.h>
+#include<ctype.h>
+#include<unistd.h>
+#define TEST_BUS_NAME_TEMP "Test.Method.Call"
+
+void called_method(DBusMessage* msg, DBusConnection* connection)
+{
+ DBusMessage* reply;
+ DBusMessageIter args;
+ DBusMessageIter in_args;
+
+ char* in_str;
+ DBusError error;
+
+ dbus_uint32_t status = 94;
+
+ dbus_error_init(&error);
+ dbus_message_iter_init(msg, &in_args);
+
+ reply = dbus_message_new_method_return(msg);
+ dbus_message_iter_init_append(reply, &args);
+
+ do{
+ dbus_message_iter_get_basic(&in_args, &in_str);
+
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &in_str);
+
+ }while(dbus_message_iter_next(&in_args));
+
+ dbus_connection_send(connection, reply, NULL);
+
+ dbus_connection_flush(connection);
+}
+
+
+void called_variable_args_method(DBusMessage* msg, DBusConnection* connection)
+{
+ DBusMessage* reply;
+ DBusMessageIter iter;
+ DBusMessageIter sub_iter;
+ void* arg = malloc(20);
+ char* str;
+ int no;
+ int i;
+ dbus_int32_t* array;
+ dbus_int32_t return_value = 0;
+ dbus_bool_t valid_flag = TRUE;
+
+
+
+
+ reply = dbus_message_new_method_return(msg);
+ dbus_message_iter_init(msg, &iter);
+
+ do{
+ switch(dbus_message_iter_get_arg_type(&iter))
+ {
+ case DBUS_TYPE_BOOLEAN:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_bool_t*)arg != TRUE)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_INT16:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_int16_t*)arg != -16)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_INT32:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_int32_t*)arg != -32)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_INT64:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_int64_t*)arg != -64)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_UINT16:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_uint16_t*)arg != 16)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_UINT32:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_uint32_t*)arg != 32)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_UINT64:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(dbus_uint64_t*)arg != 64)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_DOUBLE:
+ dbus_message_iter_get_basic(&iter, arg);
+ if(*(double*)arg != 12.34567)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_STRING:
+ dbus_message_iter_get_basic(&iter, &str);
+ if(strcmp("DBus Testing", str))
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_ARRAY:
+ dbus_message_iter_recurse(&iter, &sub_iter);
+ no = dbus_message_iter_get_array_len(&sub_iter);
+ dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
+ for(i=0;i<no;i++)
+ if(array[i] != (i+1))
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_STRUCT:
+ dbus_message_iter_recurse(&iter, &sub_iter);
+ do{
+ switch(dbus_message_iter_get_arg_type(&sub_iter))
+ {
+ case DBUS_TYPE_INT32:
+ dbus_message_iter_get_basic(&sub_iter, arg);
+ if(*(dbus_int32_t*)arg != -32)
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_STRING:
+ dbus_message_iter_get_basic(&sub_iter, &str);
+ if(strcmp("DBus Testing", str))
+ valid_flag = FALSE;
+ break;
+ case DBUS_TYPE_DOUBLE:
+ dbus_message_iter_get_basic(&sub_iter, arg);
+ if(*(double*)arg != 12.34567)
+ valid_flag = FALSE;
+ break;
+ default:
+ valid_flag = FALSE;
+
+ }
+ }while(dbus_message_iter_next(&sub_iter));
+
+ break;
+ default:
+ valid_flag = FALSE;
+ }
+ }while(dbus_message_iter_next(&iter));
+
+ if(!valid_flag)
+ return_value = 1;
+ else
+ return_value = 0;
+
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);
+ dbus_connection_send(connection, reply, NULL);
+ dbus_connection_flush(connection);
+}
+
+void called_simple(DBusMessage* msg, DBusConnection* connection)
+{
+ DBusMessage* reply;
+ dbus_int32_t return_value = 9090;
+
+ reply = dbus_message_new_method_return(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);
+ dbus_connection_send(connection, reply, NULL);
+ dbus_connection_flush(connection);
+}
+
+
+void called_file_send(DBusMessage* msg, DBusConnection* connection)
+{
+ DBusMessage* reply;
+ int return_value = 8080;
+ DBusMessageIter iter;
+ DBusMessageIter sub_iter;
+ int no;
+ unsigned char* array;
+ FILE* fp=NULL;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &sub_iter);
+ no = dbus_message_iter_get_array_len(&sub_iter);
+ dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
+
+ fp = fopen("c:\\data\\images\\pictures\\bunbask1.jpg", "a+");
+ if(!fp)
+ {
+ printf("Failed to open file");
+ return;
+ }
+
+ fwrite(array, sizeof(unsigned char), no, fp);
+
+ if(fp)
+ fclose(fp);
+
+ reply = dbus_message_new_method_return(msg);
+ dbus_connection_send(connection, reply, NULL);
+ dbus_connection_flush(connection);
+}
+
+void called_file_send_time(DBusMessage* msg,DBusConnection* connection)
+ {
+ DBusMessageIter iter;
+ DBusMessageIter sub_iter;
+ int no;
+ unsigned char* array;
+ FILE* fp=NULL;
+ DBusMessage* reply;
+ char* file_name;
+
+ reply = dbus_message_new_method_return(msg);
+ dbus_connection_send(connection, reply, NULL);
+ dbus_connection_flush(connection);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &file_name);
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &sub_iter);
+ no = dbus_message_iter_get_array_len(&sub_iter);
+ dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
+
+ strcat(file_name, "_1");
+ fp = fopen(file_name, "w+");
+ if(!fp)
+ {
+ printf("Failed to open file %s", file_name);
+ getchar();
+ }
+
+ fwrite(array, sizeof(unsigned char), no, fp);
+ if(fp)
+ fclose(fp);
+ }
+
+void called_sign_test(DBusMessage* msg, DBusConnection* connection)
+{
+ DBusError error;
+ const char* signature;
+ const char* msg_sign;
+ const char* msg_sign1;
+ DBusSignatureIter sign_iter;
+ DBusSignatureIter sub_sign_iter;
+ DBusSignatureIter sub_sign_iter1;
+ DBusMessageIter iter;
+ DBusMessage* reply;
+ int type;
+ int sub_type;
+ const char* sub_signature;
+
+ dbus_error_init(&error);
+
+ dbus_message_iter_init(msg, &iter);
+ msg_sign = dbus_message_iter_get_signature(&iter);
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_next(&iter);
+ msg_sign1 = dbus_message_iter_get_signature(&iter);
+
+ signature = dbus_message_get_signature(msg);
+ dbus_signature_iter_init(&sign_iter, signature);
+ if(dbus_signature_validate_single(signature, &error))
+ {
+ exit(1);
+ }
+ do{
+ type = dbus_signature_iter_get_current_type(&sign_iter);
+ switch(type)
+ {
+ case DBUS_TYPE_ARRAY:
+ dbus_signature_iter_recurse(&sign_iter, &sub_sign_iter1);
+ sub_type = dbus_signature_iter_get_element_type(&sign_iter);
+ break;
+ case DBUS_TYPE_STRUCT:
+ dbus_signature_iter_recurse(&sign_iter, &sub_sign_iter);
+ sub_signature = dbus_signature_iter_get_signature(&sign_iter);
+ dbus_error_init(&error);
+ if(!dbus_signature_validate_single(sub_signature, &error))
+ {
+ exit(1);
+ }
+ break;
+ }
+ }while(dbus_signature_iter_next(&sign_iter));
+
+ reply = dbus_message_new_method_return(msg);
+ dbus_message_append_args(reply, DBUS_TYPE_SIGNATURE, &signature, DBUS_TYPE_SIGNATURE, &sub_signature, DBUS_TYPE_INT32, &sub_type, DBUS_TYPE_SIGNATURE, &msg_sign, DBUS_TYPE_SIGNATURE, &msg_sign1, DBUS_TYPE_INVALID);
+ dbus_connection_send(connection, reply, NULL);
+ dbus_connection_flush(connection);
+
+ dbus_free((void*)msg_sign);
+ dbus_free((void*)msg_sign1);
+ dbus_message_unref(reply);
+}
+
+void called_file_send_whole(DBusMessage* msg, DBusConnection* connection)
+ {
+ DBusMessageIter iter;
+ DBusMessageIter sub_iter;
+ int no;
+ unsigned char* array;
+ FILE* fp=NULL;
+ DBusMessage* reply;
+
+ reply = dbus_message_new_method_return(msg);
+ dbus_connection_send(connection, reply, NULL);
+ dbus_connection_flush(connection);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &sub_iter);
+ no = dbus_message_iter_get_array_len(&sub_iter);
+ dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
+
+ fp = fopen("c:\\data\\Images\\Pictures\\test.mp3", "a+");
+ if(!fp)
+ {
+ printf("Failed to open file");
+ getchar();
+ }
+
+ fwrite(array, sizeof(unsigned char), no, fp);
+
+ if(fp)
+ fclose(fp);
+
+ dbus_message_unref(reply);
+ }
+
+int main()
+{
+ DBusError error;
+ DBusError error1;
+ DBusConnection* connection;
+ DBusMessage* msg;
+ DBusObjectPathVTable vtable =
+ {
+ NULL,NULL,NULL
+ };
+
+ dbus_error_init(&error);
+ dbus_error_init(&error1);
+
+ connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
+
+ if(dbus_error_is_set(&error))
+ {
+ fprintf(stdout, "Error Occured :: %s", error.name);
+ return 1;
+ }
+
+
+
+ if(dbus_connection_register_object_path (connection, "/Test/Method/Object", &vtable, NULL))
+ {
+ fprintf(stdout, "Object Path registered.");
+ }
+ else
+ {
+ fprintf(stdout, "Object Path not able to register.");
+ return 1;
+ }
+
+
+
+ if(dbus_bus_request_name (connection, TEST_BUS_NAME_TEMP, DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &error1) == -1)
+ {
+ fprintf(stdout, "Not able to request name.");
+ }
+ else
+ {
+ fprintf(stdout, "Name Request Successful");
+ }
+
+ while(TRUE)
+ {
+ dbus_connection_read_write(connection, 0);
+
+ msg = dbus_connection_pop_message(connection);
+
+ if(msg == NULL)
+ {
+ sleep(1);
+ continue;
+ }
+
+ fprintf(stdout, "Message Detected");
+
+ if(DBUS_MESSAGE_TYPE_SIGNAL == dbus_message_get_type(msg))
+ {
+ fprintf(stdout, "Message is Signal.");
+ }
+
+ if(DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg))
+ {
+ fprintf(stdout, "Message is Method call.");
+ }
+
+
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "method"))
+ {
+ called_method(msg, connection);
+ break;
+ }
+
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "variable_args_method"))
+ {
+
+ called_variable_args_method(msg, connection);
+ break;
+ }
+
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "simple"))
+ {
+
+ called_simple(msg, connection);
+ // break;
+ }
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send"))
+ {
+
+ called_file_send(msg, connection);
+ // break;
+ }
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "sign_test"))
+ {
+
+ called_sign_test(msg, connection);
+ break;
+ }
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send_whole"))
+ {
+
+ called_file_send_whole(msg, connection);
+ break;
+ }
+
+ if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send_time"))
+ {
+
+ called_file_send_time(msg, connection);
+ // break;
+ }
+
+ dbus_message_unref(msg);
+
+ }
+
+ dbus_message_unref(msg);
+ dbus_bus_release_name(connection,TEST_BUS_NAME_TEMP,&error1);
+ dbus_connection_unregister_object_path(connection,"/Test/Method/Object");
+
+ dbus_connection_unref(connection);
+
+ return 0;
+}