static void test_parse_xml_call(void) { xmlrpc_env env; const char *method_name; xmlrpc_value *params; int i1, i2; const char **bad_call; xml_element *elem; xmlrpc_env_init(&env); /* Parse a valid call. */ xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call), &method_name, ¶ms); TEST_NO_FAULT(&env); TEST(params != NULL); xmlrpc_decompose_value(&env, params, "(ii)", &i1, &i2); xmlrpc_DECREF(params); TEST_NO_FAULT(&env); TEST(streq(method_name, "gloom&doom")); TEST(i1 == 10 && i2 == 20); strfree(method_name); /* Test some poorly-formed XML data. */ xmlrpc_parse_call(&env, unparseable_value, strlen(unparseable_value), &method_name, ¶ms); TEST_FAULT(&env, XMLRPC_PARSE_ERROR); TEST(method_name == NULL && params == NULL); /* Next, check for bogus values. These are all well-formed XML, but they aren't legal XML-RPC. */ for (bad_call = bad_calls; *bad_call != NULL; ++bad_call) { /* First, check to make sure that our test case is well-formed XML. ** (It's easy to make mistakes when writing the test cases!) */ xml_parse(&env, *bad_call, strlen(*bad_call), &elem); TEST_NO_FAULT(&env); xml_element_free(elem); /* Now, make sure the higher-level routine barfs appropriately. */ xmlrpc_parse_call(&env, *bad_call, strlen(*bad_call), &method_name, ¶ms); TEST_FAULT(&env, XMLRPC_PARSE_ERROR); TEST(method_name == NULL && params == NULL); } xmlrpc_env_clean(&env); }
static void test_xml_size_limit(void) { xmlrpc_env env; const char * methodName; xmlrpc_value * paramsP; /* NOTE - This test suite only verifies the last-ditch size-checking code. There should also be matching code in all server (and preferably all client) modules as well. */ /* Set our XML size limit to something ridiculous. */ xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 6); /* Attempt to parse a call. */ xmlrpc_env_init(&env); xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call), &methodName, ¶msP); TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR); xmlrpc_env_clean(&env); { xmlrpc_value * resultP; int faultCode; const char * faultString; /* Attempt to parse a response. */ xmlrpc_env_init(&env); xmlrpc_parse_response2(&env, good_response_xml, strlen(good_response_xml), &resultP, &faultCode, &faultString); TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR); xmlrpc_env_clean(&env); } /* Reset the default limit. */ xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, XMLRPC_XML_SIZE_LIMIT_DEFAULT); }
static void test_sample_files (void) { xmlrpc_env env; char **paths, *path; char *data; size_t data_len; const char *method_name; xmlrpc_value *params; xmlrpc_env_init(&env); /* Test our good requests. */ for (paths = good_requests; *paths != NULL; paths++) { path = *paths; read_file(path, &data, &data_len); xmlrpc_parse_call(&env, data, data_len, &method_name, ¶ms); TEST_NO_FAULT(&env); strfree(method_name); xmlrpc_DECREF(params); } xmlrpc_env_clean(&env); }
static void testParseNumberValue(void) { char const xmldata[] = XML_PROLOGUE "<methodCall>\r\n" "<methodName>test</methodName>\r\n" "<params>\r\n" "<param><value><int>2147483647</int></value></param>\r\n" \ "<param><value><int>-2147483648</int></value></param>\r\n" \ "<param><value><i1>10</i1></value></param>\r\n" "<param><value><i2>10</i2></value></param>\r\n" "<param><value><i4>10</i4></value></param>\r\n" "<param><value><i8>10</i8></value></param>\r\n" "<param><value><ex:i8>10</ex:i8></value></param>\r\n" "<param><value><double>10</double></value></param>\r\n" "<param><value><double>10.1</double></value></param>\r\n" "<param><value><double>-10.1</double></value></param>\r\n" "<param><value><double>+10.1</double></value></param>\r\n" "<param><value><double>0</double></value></param>\r\n" "<param><value><double>.01</double></value></param>\r\n" "<param><value><double>5.</double></value></param>\r\n" "<param><value><double>5.3E6</double></value></param>\r\n" "<param><value><double> 1</double></value></param>\r\n" "</params>\r\n" "</methodCall>\r\n"; xmlrpc_env env; xmlrpc_value * paramArrayP; const char * methodName; int arraySize; xmlrpc_int int_max, int_min; xmlrpc_int32 i_i1, i_i2, i_i4; xmlrpc_int64 i_i8, i_ex_i8; double d1, d2, d3, d4, d5, d6, d7, d8, d9; xmlrpc_env_init(&env); xmlrpc_parse_call(&env, xmldata, strlen(xmldata), &methodName, ¶mArrayP); TEST_NO_FAULT(&env); arraySize = xmlrpc_array_size(&env, paramArrayP); TEST_NO_FAULT(&env); TEST(arraySize == 16); xmlrpc_decompose_value( &env, paramArrayP, "(iiiiiIIddddddddd)", &int_max, &int_min, &i_i1, &i_i2, &i_i4, &i_i8, &i_ex_i8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9); TEST_NO_FAULT(&env); TEST(int_max == INT_MAX); TEST(int_min == INT_MIN); TEST(i_i1 == 10); TEST(i_i2 == 10); TEST(i_i4 == 10); TEST(i_i8 == 10); TEST(i_ex_i8 == 10); TESTFLOATEQUAL(d1, 10.0); TESTFLOATEQUAL(d2, 10.1); TESTFLOATEQUAL(d3, -10.1); TESTFLOATEQUAL(d4, +10.1); TESTFLOATEQUAL(d5, 0.0); TESTFLOATEQUAL(d6, 0.01); TESTFLOATEQUAL(d7, 5.0); TESTFLOATEQUAL(d8, 5.3E6); TESTFLOATEQUAL(d9, 1.0); xmlrpc_DECREF(paramArrayP); strfree(methodName); xmlrpc_env_clean(&env); }
static void testParseMiscSimpleValue(void) { char const xmldata[] = XML_PROLOGUE "<methodCall>\r\n" "<methodName>test</methodName>\r\n" "<params>\r\n" "<param><value><string>hello</string></value></param>\r\n" "<param><value><boolean>0</boolean></value></param>\r\n" "<param><value><boolean>1</boolean></value></param>\r\n" "<param><value><dateTime.iso8601>19980717T14:08:55</dateTime.iso8601>" "</value></param>\r\n" "<param><value>" "<dateTime.iso8601>19980717T14:08:55.123456</dateTime.iso8601>" "</value></param>\r\n" "<param><value><base64>YmFzZTY0IGRhdGE=</base64></value></param>\r\n" "<param><value><nil/></value></param>\r\n" "<param><value><ex:nil/></value></param>\r\n" "</params>\r\n" "</methodCall>\r\n"; xmlrpc_env env; xmlrpc_value * paramArrayP; const char * methodName; int arraySize; const char * str_hello; xmlrpc_bool b_false, b_true; const char * datetime_sec; const char * datetime_usec; unsigned char * b64_data; size_t b64_len; xmlrpc_env_init(&env); xmlrpc_parse_call(&env, xmldata, strlen(xmldata), &methodName, ¶mArrayP); TEST_NO_FAULT(&env); arraySize = xmlrpc_array_size(&env, paramArrayP); TEST_NO_FAULT(&env); TEST(arraySize == 8); xmlrpc_decompose_value( &env, paramArrayP, "(sbb886nn)", &str_hello, &b_false, &b_true, &datetime_sec, &datetime_usec, &b64_data, &b64_len); TEST_NO_FAULT(&env); TEST(streq(str_hello, "hello")); TEST(!b_false); TEST(b_true); TEST(streq(datetime_sec, "19980717T14:08:55")); TEST(streq(datetime_usec, "19980717T14:08:55.123456")); TEST(b64_len == 11); TEST(memcmp(b64_data, "base64 data", b64_len) == 0); free(b64_data); strfree(str_hello); strfree(datetime_sec); strfree(datetime_usec); xmlrpc_DECREF(paramArrayP); strfree(methodName); xmlrpc_env_clean(&env); }
/************************************** * ProcessRequest * Procesa una peticion *************************************/ int XmlHandler::ProcessRequest(TRequestInfo *req,TSession * const ses) { xmlrpc_env env; int inputLen; char *method; xmlrpc_value *params = NULL; timeval tv; Log(">ProcessRequest [uri:%s]\n",req->uri); //Init timer getUpdDifTime(&tv); //Creamos un enviroment xmlrpc_env_init(&env); //Si no es post if (req->method != m_post) //Mandamos error return XmlRpcServer::SendError(ses, 405, "Only POST allowed"); //Obtenemos el content type const char * content_type = RequestHeaderValue(ses, (char*)"content-type"); //Si no es el bueno if (content_type == NULL || strcmp(content_type, "text/xml") != 0) return XmlRpcServer::SendError(ses, 400, "Wrong content-type"); //Obtenemos el content length const char * content_length = RequestHeaderValue(ses, (char*)"content-length"); //Si no hay if (content_length == NULL) return XmlRpcServer::SendError(ses,411,"No content-length"); //Obtenemos el entero inputLen = atoi(content_length); //Tiene que ser mayor que cero if ((inputLen < 0) || (inputLen > xmlrpc_limit_get(XMLRPC_XML_SIZE_LIMIT_ID))) return XmlRpcServer::SendError(ses,400,"Size limit"); //Creamos un buffer para el body char * buffer = (char *) malloc(inputLen); if (!XmlRpcServer::GetBody(ses,buffer,inputLen)) { //LIberamos el buffer free(buffer); //Y salimos sin devolver nada Log("Operation timedout\n"); return 1; } //Get method name xmlrpc_parse_call(&env,buffer,inputLen,(const char**)&method,¶ms); Log("-ProcessRequest [method:%s]\n",method); //Free name and params free(method); xmlrpc_DECREF(params); //Generamos la respuesta xmlrpc_mem_block *output = xmlrpc_registry_process_call( &env, registry, NULL, buffer, inputLen ); //Si todo ha ido bien if (!env.fault_occurred) { //POnemos el content type ResponseContentType(ses, (char*)"text/xml; charset=\"utf-8\""); //Y mandamos la respuesta XmlRpcServer::SendResponse(ses,200,XMLRPC_MEMBLOCK_CONTENTS(char, output), XMLRPC_MEMBLOCK_SIZE(char, output)); } else