SOAP: Difference between revisions
Content added Content deleted
(Added Wren) |
|||
Line 585: | Line 585: | ||
uResult := oSoapClient:anotherSoapFunc(34234) |
uResult := oSoapClient:anotherSoapFunc(34234) |
||
ENDIF</lang> |
ENDIF</lang> |
||
=={{header|Wren}}== |
|||
{{trans|C}} |
|||
{{libheader|libcurl}} |
|||
An embedded program so we can ask the C host to communicate with libcurl for us. |
|||
<lang ecmascript>/* soap.wren */ |
|||
var CURLOPT_URL = 10002 |
|||
var CURLOPT_POST = 47 |
|||
var CURLOPT_READFUNCTION = 20012 |
|||
var CURLOPT_READDATA = 10009 |
|||
var CURLOPT_WRITEFUNCTION = 20011 |
|||
var CURLOPT_WRITEDATA = 10001 |
|||
var CURLOPT_HTTPHEADER = 10023 |
|||
var CURLOPT_POSTFIELDSIZE_LARGE = 30120 |
|||
var CURLOPT_VERBOSE = 41 |
|||
foreign class File { |
|||
foreign static url |
|||
foreign static readFile |
|||
foreign static writeFile |
|||
construct open(filename, mode) {} |
|||
} |
|||
foreign class CurlSlist { |
|||
construct new() {} |
|||
foreign append(s) |
|||
} |
|||
foreign class Curl { |
|||
construct easyInit() {} |
|||
foreign easySetOpt(opt, param) |
|||
foreign easyPerform() |
|||
foreign easyCleanup() |
|||
} |
|||
var soap = Fn.new { |url, inFile, outFile| |
|||
var rfp = File.open(inFile, "r") |
|||
if (rfp == 0) Fiber.abort("Error opening read file.") |
|||
var wfp = File.open(outFile, "w+") |
|||
if (wfp == 0) Fiber.abort("Error opening write file.") |
|||
var header = CurlSlist.new() |
|||
header = header.append("Content-Type:text/xml") |
|||
header = header.append("SOAPAction: rsc") |
|||
header = header.append("Transfer-Encoding: chunked") |
|||
header = header.append("Expect:") |
|||
var curl = Curl.easyInit() |
|||
if (curl == 0) Fiber.abort("Error initializing cURL.") |
|||
curl.easySetOpt(CURLOPT_URL, url) |
|||
curl.easySetOpt(CURLOPT_POST, 1) |
|||
curl.easySetOpt(CURLOPT_READFUNCTION, 0) // read function to be supplied by C |
|||
curl.easySetOpt(CURLOPT_READDATA, rfp) |
|||
curl.easySetOpt(CURLOPT_WRITEFUNCTION, 0) // write function to be supplied by C |
|||
curl.easySetOpt(CURLOPT_WRITEDATA, wfp) |
|||
curl.easySetOpt(CURLOPT_HTTPHEADER, header) |
|||
curl.easySetOpt(CURLOPT_POSTFIELDSIZE_LARGE, -1) |
|||
curl.easySetOpt(CURLOPT_VERBOSE, 1) |
|||
curl.easyPerform() |
|||
curl.easyCleanup() |
|||
} |
|||
soap.call(File.url, File.readFile, File.writeFile)</lang> |
|||
<br> |
|||
We now embed this in the following C program, compile and run it. |
|||
<lang c>#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include <curl/curl.h> |
|||
#include "wren.h" |
|||
/* C <=> Wren interface functions */ |
|||
char *url, *read_file, *write_file; |
|||
size_t write_data(void *ptr, size_t size, size_t nmeb, void *stream) { |
|||
return fwrite(ptr, size, nmeb, stream); |
|||
} |
|||
size_t read_data(void *ptr, size_t size, size_t nmeb, void *stream) { |
|||
return fread(ptr, size, nmeb, stream); |
|||
} |
|||
void C_url(WrenVM* vm) { |
|||
wrenSetSlotString(vm, 0, url); |
|||
} |
|||
void C_readFile(WrenVM* vm) { |
|||
wrenSetSlotString(vm, 0, read_file); |
|||
} |
|||
void C_writeFile(WrenVM* vm) { |
|||
wrenSetSlotString(vm, 0, write_file); |
|||
} |
|||
void C_fileAllocate(WrenVM* vm) { |
|||
FILE** fp = (FILE**)wrenSetSlotNewForeign(vm, 0, 0, sizeof(FILE*)); |
|||
const char *filename = wrenGetSlotString(vm, 1); |
|||
const char *mode = wrenGetSlotString(vm, 2); |
|||
*fp = fopen(filename, mode); |
|||
} |
|||
void C_curlSlistAllocate(WrenVM* vm) { |
|||
wrenSetSlotNewForeign(vm, 0, 0, sizeof(struct curl_slist*)); |
|||
} |
|||
void C_curlAllocate(WrenVM* vm) { |
|||
CURL** pcurl = (CURL**)wrenSetSlotNewForeign(vm, 0, 0, sizeof(CURL*)); |
|||
*pcurl = curl_easy_init(); |
|||
} |
|||
void C_append(WrenVM* vm) { |
|||
struct curl_slist** plist = (struct curl_slist**)wrenGetSlotForeign(vm, 0); |
|||
const char *s = wrenGetSlotString(vm, 1); |
|||
*plist = curl_slist_append(*plist, s); |
|||
} |
|||
void C_easyPerform(WrenVM* vm) { |
|||
CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0); |
|||
curl_easy_perform(curl); |
|||
} |
|||
void C_easyCleanup(WrenVM* vm) { |
|||
CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0); |
|||
curl_easy_cleanup(curl); |
|||
} |
|||
void C_easySetOpt(WrenVM* vm) { |
|||
CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0); |
|||
CURLoption opt = (CURLoption)wrenGetSlotDouble(vm, 1); |
|||
if (opt < 10000) { |
|||
long lparam = (long)wrenGetSlotDouble(vm, 2); |
|||
curl_easy_setopt(curl, opt, lparam); |
|||
} else if (opt < 20000) { |
|||
if (opt == CURLOPT_WRITEDATA || opt == CURLOPT_READDATA) { |
|||
FILE *fp = *(FILE**)wrenGetSlotForeign(vm, 2); |
|||
curl_easy_setopt(curl, opt, fp); |
|||
} else if (opt == CURLOPT_URL) { |
|||
const char *url = wrenGetSlotString(vm, 2); |
|||
curl_easy_setopt(curl, opt, url); |
|||
} else if (opt == CURLOPT_HTTPHEADER) { |
|||
struct curl_slist* header = *(struct curl_slist**)wrenGetSlotForeign(vm, 2); |
|||
curl_easy_setopt(curl, opt, header); |
|||
} |
|||
} else if (opt < 30000) { |
|||
if (opt == CURLOPT_READFUNCTION) { |
|||
curl_easy_setopt(curl, opt, &read_data); |
|||
} else if (opt == CURLOPT_WRITEFUNCTION) { |
|||
curl_easy_setopt(curl, opt, &write_data); |
|||
} |
|||
} else { |
|||
curl_off_t cparam = (curl_off_t)wrenGetSlotDouble(vm, 2); |
|||
curl_easy_setopt(curl, opt, cparam); |
|||
} |
|||
} |
|||
WrenForeignClassMethods bindForeignClass(WrenVM* vm, const char* module, const char* className) { |
|||
WrenForeignClassMethods methods; |
|||
methods.allocate = NULL; |
|||
methods.finalize = NULL; |
|||
if (strcmp(module, "main") == 0) { |
|||
if (strcmp(className, "File") == 0) { |
|||
methods.allocate = C_fileAllocate; |
|||
} else if (strcmp(className, "CurlSlist") == 0) { |
|||
methods.allocate = C_curlSlistAllocate; |
|||
} else if (strcmp(className, "Curl") == 0) { |
|||
methods.allocate = C_curlAllocate; |
|||
} |
|||
} |
|||
return methods; |
|||
} |
|||
WrenForeignMethodFn bindForeignMethod( |
|||
WrenVM* vm, |
|||
const char* module, |
|||
const char* className, |
|||
bool isStatic, |
|||
const char* signature) { |
|||
if (strcmp(module, "main") == 0) { |
|||
if (strcmp(className, "File") == 0) { |
|||
if (isStatic && strcmp(signature, "url") == 0) return C_url; |
|||
if (isStatic && strcmp(signature, "readFile") == 0) return C_readFile; |
|||
if (isStatic && strcmp(signature, "writeFile") == 0) return C_writeFile; |
|||
} else if (strcmp(className, "CurlSlist") == 0) { |
|||
if (!isStatic && strcmp(signature, "append(_)") == 0) return C_append; |
|||
} else if (strcmp(className, "Curl") == 0) { |
|||
if (!isStatic && strcmp(signature, "easySetOpt(_,_)") == 0) return C_easySetOpt; |
|||
if (!isStatic && strcmp(signature, "easyPerform()") == 0) return C_easyPerform; |
|||
if (!isStatic && strcmp(signature, "easyCleanup()") == 0) return C_easyCleanup; |
|||
} |
|||
} |
|||
return NULL; |
|||
} |
|||
static void writeFn(WrenVM* vm, const char* text) { |
|||
printf("%s", text); |
|||
} |
|||
void errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) { |
|||
switch (errorType) { |
|||
case WREN_ERROR_COMPILE: |
|||
printf("[%s line %d] [Error] %s\n", module, line, msg); |
|||
break; |
|||
case WREN_ERROR_STACK_TRACE: |
|||
printf("[%s line %d] in %s\n", module, line, msg); |
|||
break; |
|||
case WREN_ERROR_RUNTIME: |
|||
printf("[Runtime Error] %s\n", msg); |
|||
break; |
|||
} |
|||
} |
|||
char *readFile(const char *fileName) { |
|||
FILE *f = fopen(fileName, "r"); |
|||
fseek(f, 0, SEEK_END); |
|||
long fsize = ftell(f); |
|||
rewind(f); |
|||
char *script = malloc(fsize + 1); |
|||
fread(script, 1, fsize, f); |
|||
fclose(f); |
|||
script[fsize] = 0; |
|||
return script; |
|||
} |
|||
int main(int argc, char **argv) { |
|||
if (argc != 4 ) { |
|||
printf("Usage : %s <URL of WSDL> <Input file path> <Output file path>", argv[0]); |
|||
return 0; |
|||
} |
|||
url = argv[1]; |
|||
read_file = argv[2]; |
|||
write_file = argv[3]; |
|||
WrenConfiguration config; |
|||
wrenInitConfiguration(&config); |
|||
config.writeFn = &writeFn; |
|||
config.errorFn = &errorFn; |
|||
config.bindForeignClassFn = &bindForeignClass; |
|||
config.bindForeignMethodFn = &bindForeignMethod; |
|||
WrenVM* vm = wrenNewVM(&config); |
|||
const char* module = "main"; |
|||
const char* fileName = "soap.wren"; |
|||
char *script = readFile(fileName); |
|||
WrenInterpretResult result = wrenInterpret(vm, module, script); |
|||
switch (result) { |
|||
case WREN_RESULT_COMPILE_ERROR: |
|||
printf("Compile Error!\n"); |
|||
break; |
|||
case WREN_RESULT_RUNTIME_ERROR: |
|||
printf("Runtime Error!\n"); |
|||
break; |
|||
case WREN_RESULT_SUCCESS: |
|||
break; |
|||
} |
|||
wrenFreeVM(vm); |
|||
free(script); |
|||
return 0; |
|||
}</lang> |
|||
{{omit from|Batch File|Does not have network access.}} |
{{omit from|Batch File|Does not have network access.}} |