MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/ofdbus/dbus/tsrc/testapps/method/src/method.c
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include<stdio.h>  

    20 #include "test-utils.h"

    21 #include<string.h> 

    22 #include<ctype.h>

    23 #include<unistd.h>  

    24 #define TEST_BUS_NAME_TEMP "Test.Method.Call"

    25  

    26 void called_method(DBusMessage* msg, DBusConnection* connection)

    27 {

    28 	DBusMessage* reply; 

    29 	DBusMessageIter args;

    30 	DBusMessageIter in_args;

    31 	

    32 	char* in_str;

    33 	DBusError error;

    34 	   

    35 	dbus_uint32_t status = 94;

    36 

    37 	dbus_error_init(&error);

    38 	dbus_message_iter_init(msg, &in_args);

    39 	 

    40 	reply = dbus_message_new_method_return(msg);

    41 	dbus_message_iter_init_append(reply, &args);

    42 	  

    43 	do{

    44 		dbus_message_iter_get_basic(&in_args, &in_str);

    45 					

    46 		dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &in_str);

    47 		

    48 	}while(dbus_message_iter_next(&in_args));

    49 	 

    50 	dbus_connection_send(connection, reply, NULL);

    51 	

    52 	dbus_connection_flush(connection);

    53 }

    54 

    55 

    56 void called_variable_args_method(DBusMessage* msg, DBusConnection* connection)

    57 {

    58 	DBusMessage* reply;

    59 	DBusMessageIter iter;

    60 	DBusMessageIter sub_iter;

    61 	void* arg = malloc(20);

    62 	char* str;

    63 	int no;

    64 	int i;

    65 	dbus_int32_t* array;

    66 	dbus_int32_t return_value = 0;

    67 	dbus_bool_t valid_flag = TRUE;

    68 	

    69 

    70 	

    71 	

    72 	reply = dbus_message_new_method_return(msg);

    73 	dbus_message_iter_init(msg, &iter);

    74 	

    75 	do{

    76 		switch(dbus_message_iter_get_arg_type(&iter))

    77 		{

    78 			case DBUS_TYPE_BOOLEAN:

    79 				dbus_message_iter_get_basic(&iter, arg);

    80 				if(*(dbus_bool_t*)arg != TRUE)

    81 					valid_flag = FALSE;

    82 				break;

    83 			case DBUS_TYPE_INT16:

    84 				dbus_message_iter_get_basic(&iter, arg);

    85 				if(*(dbus_int16_t*)arg != -16)

    86 					valid_flag = FALSE;

    87 				break;

    88 			case DBUS_TYPE_INT32:

    89 				dbus_message_iter_get_basic(&iter, arg);

    90 				if(*(dbus_int32_t*)arg != -32)

    91 					valid_flag = FALSE;

    92 				break;

    93 			case DBUS_TYPE_INT64:

    94 				dbus_message_iter_get_basic(&iter, arg);

    95 				if(*(dbus_int64_t*)arg != -64)

    96 					valid_flag = FALSE;

    97 				break;

    98 			case DBUS_TYPE_UINT16:

    99 				dbus_message_iter_get_basic(&iter, arg);

   100 				if(*(dbus_uint16_t*)arg != 16)

   101 					valid_flag = FALSE;

   102 				break;

   103 			case DBUS_TYPE_UINT32:

   104 				dbus_message_iter_get_basic(&iter, arg);

   105 				if(*(dbus_uint32_t*)arg != 32)

   106 					valid_flag = FALSE;

   107 				break;

   108 			case DBUS_TYPE_UINT64:

   109 				dbus_message_iter_get_basic(&iter, arg);

   110 				if(*(dbus_uint64_t*)arg != 64)

   111 					valid_flag = FALSE;

   112 				break;

   113 			case DBUS_TYPE_DOUBLE:

   114 				dbus_message_iter_get_basic(&iter, arg);

   115 				if(*(double*)arg != 12.34567)

   116 					valid_flag = FALSE;

   117 				break;

   118 			case DBUS_TYPE_STRING:

   119 				dbus_message_iter_get_basic(&iter, &str);

   120 				if(strcmp("DBus Testing", str))

   121 					valid_flag = FALSE;

   122 				break;

   123 			case DBUS_TYPE_ARRAY: 

   124 				dbus_message_iter_recurse(&iter, &sub_iter);

   125 				no = dbus_message_iter_get_array_len(&sub_iter);

   126 				dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);

   127 				for(i=0;i<no;i++)

   128 					if(array[i] != (i+1))

   129 						valid_flag = FALSE;

   130 				break;

   131 			case DBUS_TYPE_STRUCT: 

   132 				dbus_message_iter_recurse(&iter, &sub_iter);

   133 				do{

   134 					switch(dbus_message_iter_get_arg_type(&sub_iter))

   135 					{

   136 					case DBUS_TYPE_INT32: 

   137 						dbus_message_iter_get_basic(&sub_iter, arg);

   138 						if(*(dbus_int32_t*)arg != -32)

   139 							valid_flag = FALSE;

   140 						break;    

   141 					case DBUS_TYPE_STRING:

   142 						dbus_message_iter_get_basic(&sub_iter, &str);

   143 						if(strcmp("DBus Testing", str))

   144 							valid_flag = FALSE;

   145 						break;

   146 					case DBUS_TYPE_DOUBLE:

   147 						dbus_message_iter_get_basic(&sub_iter, arg);

   148 						if(*(double*)arg != 12.34567)

   149 							valid_flag = FALSE;

   150 						break;

   151 					default: 

   152 						valid_flag = FALSE;

   153 					

   154 					}                               

   155 				}while(dbus_message_iter_next(&sub_iter));

   156 				

   157 				break; 

   158 			default: 

   159 				valid_flag = FALSE;

   160 		}

   161 	}while(dbus_message_iter_next(&iter));

   162 	

   163 	if(!valid_flag)

   164 		return_value = 1;

   165 	else

   166 		return_value = 0;

   167 	

   168 	dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);

   169 	dbus_connection_send(connection, reply, NULL);

   170 	dbus_connection_flush(connection);

   171 }

   172  

   173 void called_simple(DBusMessage* msg, DBusConnection* connection)

   174 {

   175 	DBusMessage* reply;	

   176 	dbus_int32_t return_value = 9090;

   177 	

   178 	reply = dbus_message_new_method_return(msg);

   179 	

   180 	dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);

   181 	dbus_connection_send(connection, reply, NULL);

   182 	dbus_connection_flush(connection);

   183 }

   184 

   185 

   186 void called_file_send(DBusMessage* msg, DBusConnection* connection)

   187 {

   188 	DBusMessage* reply;

   189 	int return_value = 8080;

   190 	DBusMessageIter iter;

   191 	DBusMessageIter sub_iter;

   192 	int no; 

   193 	unsigned char* array;

   194 	FILE* fp=NULL; 

   195 	

   196 	dbus_message_iter_init(msg, &iter);

   197 	dbus_message_iter_recurse(&iter, &sub_iter);

   198 	no = dbus_message_iter_get_array_len(&sub_iter);

   199 	dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);

   200 	

   201 	fp = fopen("c:\\data\\images\\pictures\\bunbask1.jpg", "a+"); 

   202 	if(!fp) 

   203 	{

   204 		printf("Failed to open file");

   205 		return;

   206 	}

   207 	

   208 	fwrite(array, sizeof(unsigned char), no, fp);

   209 	

   210 	if(fp)

   211 		fclose(fp);

   212 	

   213 	reply = dbus_message_new_method_return(msg);

   214 	dbus_connection_send(connection, reply, NULL);

   215 	dbus_connection_flush(connection);

   216 }

   217 

   218 void called_file_send_time(DBusMessage* msg,DBusConnection* connection)

   219 	{

   220 		DBusMessageIter iter;

   221 		DBusMessageIter sub_iter;

   222 		int no; 

   223 		unsigned char* array;

   224 		FILE* fp=NULL; 

   225 		DBusMessage* reply;

   226 		char* file_name;

   227 		

   228 		reply = dbus_message_new_method_return(msg);

   229 		dbus_connection_send(connection, reply, NULL);

   230 		dbus_connection_flush(connection);

   231 		

   232 		dbus_message_iter_init(msg, &iter);

   233 		dbus_message_iter_get_basic(&iter, &file_name);

   234 		dbus_message_iter_next(&iter);

   235 		dbus_message_iter_recurse(&iter, &sub_iter);

   236 		no = dbus_message_iter_get_array_len(&sub_iter);

   237 		dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);

   238 		

   239 		strcat(file_name, "_1");

   240 		fp = fopen(file_name, "w+");

   241 		if(!fp) 

   242 		{

   243 			printf("Failed to open file %s", file_name);

   244 			getchar();

   245 		}

   246 		

   247 		fwrite(array, sizeof(unsigned char), no, fp);

   248 		if(fp)

   249 			fclose(fp);

   250 	}

   251 

   252 void called_sign_test(DBusMessage* msg, DBusConnection* connection)

   253 {

   254 	DBusError error;

   255 	const char* signature;

   256 	const char* msg_sign;

   257 	const char* msg_sign1;

   258 	DBusSignatureIter sign_iter;

   259 	DBusSignatureIter sub_sign_iter;

   260 	DBusSignatureIter sub_sign_iter1;

   261 	DBusMessageIter iter;

   262 	DBusMessage* reply;

   263 	int type;

   264 	int sub_type;

   265 	const char* sub_signature;

   266 	

   267 	dbus_error_init(&error);

   268 	

   269 	dbus_message_iter_init(msg, &iter);

   270 	msg_sign = dbus_message_iter_get_signature(&iter);

   271 	dbus_message_iter_next(&iter);

   272 	dbus_message_iter_next(&iter);

   273 	msg_sign1 = dbus_message_iter_get_signature(&iter);

   274 	

   275 	signature = dbus_message_get_signature(msg);

   276 	dbus_signature_iter_init(&sign_iter, signature);

   277 	if(dbus_signature_validate_single(signature, &error))

   278 	{

   279 		exit(1);

   280 	}

   281 	do{

   282 		type = dbus_signature_iter_get_current_type(&sign_iter);

   283 		switch(type)

   284 		{

   285 		case DBUS_TYPE_ARRAY:

   286 			dbus_signature_iter_recurse(&sign_iter, &sub_sign_iter1);

   287 			sub_type = dbus_signature_iter_get_element_type(&sign_iter);

   288 			break;

   289 		case DBUS_TYPE_STRUCT:

   290 			dbus_signature_iter_recurse(&sign_iter, &sub_sign_iter);

   291 			sub_signature = dbus_signature_iter_get_signature(&sign_iter); 

   292 			dbus_error_init(&error);

   293 			if(!dbus_signature_validate_single(sub_signature, &error))

   294 			{

   295 				exit(1);

   296 			}

   297 			break;

   298 		}

   299 	}while(dbus_signature_iter_next(&sign_iter));

   300 	

   301 	reply = dbus_message_new_method_return(msg);

   302 	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);

   303 	dbus_connection_send(connection, reply, NULL);

   304 	dbus_connection_flush(connection);

   305 	

   306 	dbus_free((void*)msg_sign);

   307 	dbus_free((void*)msg_sign1);

   308 	dbus_message_unref(reply);

   309 }

   310 

   311 void called_file_send_whole(DBusMessage* msg, DBusConnection* connection)

   312 	{

   313 		DBusMessageIter iter;

   314 		DBusMessageIter sub_iter;

   315 		int no; 

   316 		unsigned char* array;

   317 		FILE* fp=NULL;

   318 		DBusMessage* reply;

   319 		

   320 		reply = dbus_message_new_method_return(msg);

   321 		dbus_connection_send(connection, reply, NULL);

   322 		dbus_connection_flush(connection);

   323 		

   324 		dbus_message_iter_init(msg, &iter);

   325 		dbus_message_iter_recurse(&iter, &sub_iter);

   326 		no = dbus_message_iter_get_array_len(&sub_iter);

   327 		dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);

   328 		

   329 		fp = fopen("c:\\data\\Images\\Pictures\\test.mp3", "a+"); 

   330 		if(!fp) 

   331 		{

   332 			printf("Failed to open file");

   333 			getchar();

   334 		}

   335 		

   336 		fwrite(array, sizeof(unsigned char), no, fp);

   337 		

   338 		if(fp)

   339 			fclose(fp);

   340 		

   341 		dbus_message_unref(reply);

   342 	}

   343 

   344 int main()

   345 {

   346 	DBusError error;

   347 	DBusError error1;

   348 	DBusConnection* connection;

   349 	DBusMessage* msg;

   350 	DBusObjectPathVTable vtable = 

   351 	{

   352 		NULL,NULL,NULL

   353 	}; 

   354 	

   355 	dbus_error_init(&error);

   356 	dbus_error_init(&error1);

   357 

   358 	connection = dbus_bus_get(DBUS_BUS_SESSION, &error);

   359 	

   360 	if(dbus_error_is_set(&error))

   361 	{

   362 		fprintf(stdout, "Error Occured :: %s", error.name);

   363 		return 1;

   364 	}

   365 	

   366 

   367 	

   368 	if(dbus_connection_register_object_path (connection, "/Test/Method/Object", &vtable, NULL))

   369 	{

   370 		fprintf(stdout, "Object Path registered.");

   371 	}

   372 	else

   373 	{

   374 		fprintf(stdout, "Object Path not able to register.");

   375 		return 1;

   376 	}

   377  

   378 

   379 

   380 	if(dbus_bus_request_name (connection, TEST_BUS_NAME_TEMP, DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &error1) == -1)

   381 	{

   382 		fprintf(stdout, "Not able to request name.");

   383 	}

   384 	else

   385 	{

   386 		fprintf(stdout, "Name Request Successful");

   387 	}

   388 	

   389 	while(TRUE)

   390 	{	

   391 		dbus_connection_read_write(connection, 0);

   392 		

   393 		msg = dbus_connection_pop_message(connection);

   394 			

   395 		if(msg == NULL)

   396 		{

   397 			sleep(1);

   398 			continue;

   399 		}

   400 		     

   401 		fprintf(stdout, "Message Detected");

   402 		

   403 		if(DBUS_MESSAGE_TYPE_SIGNAL == dbus_message_get_type(msg))

   404 		{

   405 			fprintf(stdout, "Message is Signal.");

   406 		}

   407 		

   408 		if(DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg))

   409 		{

   410 			fprintf(stdout, "Message is Method call.");

   411 		}

   412 		

   413 				

   414 		if(dbus_message_is_method_call(msg, "test.Method.Call", "method"))

   415 			{

   416 			called_method(msg, connection);

   417 			break;

   418 			} 

   419 		

   420 		if(dbus_message_is_method_call(msg, "test.Method.Call", "variable_args_method"))

   421 			{

   422 			

   423 			called_variable_args_method(msg, connection);

   424 			break;

   425 			} 

   426 		 

   427 		if(dbus_message_is_method_call(msg, "test.Method.Call", "simple"))

   428 			{

   429 			

   430 			called_simple(msg, connection);

   431 	//		break;

   432 			}

   433 		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send"))

   434 			{

   435 			

   436 			called_file_send(msg, connection);

   437 	//		break; 

   438 			} 

   439 		if(dbus_message_is_method_call(msg, "test.Method.Call", "sign_test"))

   440 			{

   441 			

   442 			called_sign_test(msg, connection);

   443 			break; 

   444 			} 

   445 		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send_whole"))

   446 			{

   447 			

   448 			called_file_send_whole(msg, connection);

   449 			break; 

   450 			}

   451 		

   452 		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send_time"))

   453 			{

   454 			

   455 			called_file_send_time(msg, connection);

   456 	//		break;

   457 			}

   458 		

   459 	dbus_message_unref(msg);	

   460 		

   461 	}

   462 	

   463 	dbus_message_unref(msg);

   464 	dbus_bus_release_name(connection,TEST_BUS_NAME_TEMP,&error1);

   465 	dbus_connection_unregister_object_path(connection,"/Test/Method/Object");

   466 

   467 	dbus_connection_unref(connection);	

   468 

   469 	return 0;

   470 }
Symaptic