/************************************************************************** * WsCreateServiceProxy [webservices.@] */ HRESULT WINAPI WsCreateServiceProxy( const WS_CHANNEL_TYPE type, const WS_CHANNEL_BINDING binding, const WS_SECURITY_DESCRIPTION *desc, const WS_PROXY_PROPERTY *proxy_props, ULONG proxy_props_count, const WS_CHANNEL_PROPERTY *channel_props, const ULONG channel_props_count, WS_SERVICE_PROXY **handle, WS_ERROR *error ) { WS_CHANNEL *channel; HRESULT hr; TRACE( "%u %u %p %p %u %p %u %p %p\n", type, binding, desc, proxy_props, proxy_props_count, channel_props, channel_props_count, handle, error ); if (error) FIXME( "ignoring error parameter\n" ); if (desc) FIXME( "ignoring security description\n" ); if (!handle) return E_INVALIDARG; if ((hr = WsCreateChannel( type, binding, channel_props, channel_props_count, NULL, &channel, NULL )) != S_OK) return hr; if ((hr = create_proxy( channel, proxy_props, proxy_props_count, handle )) != S_OK) { WsFreeChannel( channel ); return hr; } TRACE( "created %p\n", *handle ); return S_OK; }
/************************************************************************** * WsCreateServiceProxyFromTemplate [webservices.@] */ HRESULT WINAPI WsCreateServiceProxyFromTemplate( WS_CHANNEL_TYPE channel_type, const WS_PROXY_PROPERTY *properties, const ULONG count, WS_BINDING_TEMPLATE_TYPE type, void *value, ULONG size, const void *desc, ULONG desc_size, WS_SERVICE_PROXY **handle, WS_ERROR *error ) { const WS_CHANNEL_PROPERTY *channel_props = NULL; ULONG channel_props_count = 0; WS_CHANNEL_BINDING binding; WS_CHANNEL *channel; HRESULT hr; TRACE( "%u %p %u %u %p %u %p %u %p %p\n", channel_type, properties, count, type, value, size, desc, desc_size, handle, error ); if (error) FIXME( "ignoring error parameter\n" ); if (!desc || !handle) return E_INVALIDARG; FIXME( "ignoring description\n" ); switch (type) { case WS_HTTP_BINDING_TEMPLATE_TYPE: { WS_HTTP_BINDING_TEMPLATE *http = value; if (http) { channel_props = http->channelProperties.properties; channel_props_count = http->channelProperties.propertyCount; } binding = WS_HTTP_CHANNEL_BINDING; break; } case WS_HTTP_SSL_BINDING_TEMPLATE_TYPE: { WS_HTTP_SSL_BINDING_TEMPLATE *https = value; if (https) { channel_props = https->channelProperties.properties; channel_props_count = https->channelProperties.propertyCount; } binding = WS_HTTP_CHANNEL_BINDING; break; } default: FIXME( "template type %u not implemented\n", type ); return E_NOTIMPL; } if ((hr = WsCreateChannel( channel_type, binding, channel_props, channel_props_count, NULL, &channel, NULL )) != S_OK) return hr; if ((hr = create_proxy( channel, properties, count, handle )) != S_OK) { WsFreeChannel( channel ); return hr; } TRACE( "created %p\n", *handle ); return S_OK; }
static void wrt_connect_cb(mrp_transport_t *t, void *user_data) { static proxy_ops_t ops = { .send_msg = wrt_op_send_msg, .unref = wrt_op_unref_msg, .create_notify = wrt_op_create_notify, .update_notify = wrt_op_update_notify, .send_notify = wrt_op_send_notify, .free_notify = wrt_op_free_notify, }; pdp_t *pdp = (pdp_t *)user_data; pep_proxy_t *proxy; int flags; proxy = create_proxy(pdp); if (proxy != NULL) { flags = MRP_TRANSPORT_REUSEADDR | MRP_TRANSPORT_NONBLOCK; proxy->t = mrp_transport_accept(t, proxy, flags); if (proxy->t != NULL) { proxy->ops = &ops; mrp_log_info("Accepted new client connection."); } else { mrp_log_error("Failed to accept new client connection."); destroy_proxy(proxy); } } }
static void pushvalue(lua_State *L, const void *v, int type, const struct document * doc) { switch (type) { case VALUE_NIL: lua_pushnil(L); break; case VALUE_INTEGER: lua_pushinteger(L, (int32_t)getuint32(v)); break; case VALUE_REAL: lua_pushnumber(L, getfloat(v)); break; case VALUE_BOOLEAN: lua_pushboolean(L, getuint32(v)); break; case VALUE_TABLE: create_proxy(L, doc, getuint32(v)); break; case VALUE_STRING: lua_pushstring(L, (const char *)doc + doc->strtbl + getuint32(v)); break; default: luaL_error(L, "Invalid type %d at %p", type, v); } }
static PyObject * api_create(PyObject *object) { if (object == NULL) { PyErr_SetString(PyExc_ValueError, "cannot create proxy around NULL"); return NULL; } return create_proxy(object); }
int main(int argc, char* argv[]) { int client, server; int master_sock; int localport; char* log_file_loc; if (argc == 4) { if (strcmp(argv[1], "-v") != 0) { show_usage(argv[0]); } verbose = true; localport = atoi(argv[2]); log_file_loc = argv[3]; } else if (argc == 3) { localport = atoi(argv[1]); log_file_loc = argv[2]; } else { show_usage(argv[0]); } if (strcmp(log_file_loc, "stdout") == 0) { logfile = stdout; verbose = false; } else { logfile = fopen(log_file_loc, "a"); } if (logfile == NULL) { fprintf(stderr, "log_file %s could not be opened\n", argv[2]); exit(2); } assert(localport > 0); signal(SIGINT, cleanup); signal(SIGCHLD, sigreap); master_sock = create_server_sock(localport); for (;;) { if ((client = wait_for_connection(master_sock)) < 0) { continue; } if ((server = create_proxy(client)) < 0) { continue; } if (!fork()) { syslog(LOG_INFO, "connecting to %s:%d fd=%d\n", remoteaddr, remoteport, server); service_client(client, server); } close(client); close(server); } }
static int lnew(lua_State *L) { luaL_checktype(L, 1, LUA_TLIGHTUSERDATA); const char * data = lua_touserdata(L, 1); // hold ref to data lua_getfield(L, LUA_REGISTRYINDEX, TABLES); lua_pushvalue(L, 1); lua_rawsetp(L, -2, data); create_proxy(L, data, 0); return 1; }
HRESULT StdProxy_Construct(REFIID riid, LPUNKNOWN pUnkOuter, const ProxyFileInfo *ProxyInfo, int Index, LPPSFACTORYBUFFER pPSFactory, LPRPCPROXYBUFFER *ppProxy, LPVOID *ppvObj) { StdProxyImpl *This; PCInterfaceName name = ProxyInfo->pNamesArray[Index]; CInterfaceProxyVtbl *vtbl = ProxyInfo->pProxyVtblList[Index]; TRACE("(%p,%p,%p,%p,%p) %s\n", pUnkOuter, vtbl, pPSFactory, ppProxy, ppvObj, name); /* TableVersion = 2 means it is the stubless version of CInterfaceProxyVtbl */ if (ProxyInfo->TableVersion > 1) { ULONG count = ProxyInfo->pStubVtblList[Index]->header.DispatchTableCount; vtbl = (CInterfaceProxyVtbl *)((const void **)vtbl + 1); TRACE("stubless vtbl %p: count=%d\n", vtbl->Vtbl, count ); fill_stubless_table( (IUnknownVtbl *)vtbl->Vtbl, count ); } if (!IsEqualGUID(vtbl->header.piid, riid)) { ERR("IID mismatch during proxy creation\n"); return RPC_E_UNEXPECTED; } This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(StdProxyImpl)); if (!This) return E_OUTOFMEMORY; if (!pUnkOuter) pUnkOuter = (IUnknown *)This; This->IRpcProxyBuffer_iface.lpVtbl = &StdProxy_Vtbl; This->PVtbl = vtbl->Vtbl; /* one reference for the proxy */ This->RefCount = 1; This->piid = vtbl->header.piid; This->base_object = NULL; This->base_proxy = NULL; This->pUnkOuter = pUnkOuter; This->name = name; This->pPSFactory = pPSFactory; This->pChannel = NULL; if(ProxyInfo->pDelegatedIIDs && ProxyInfo->pDelegatedIIDs[Index]) { HRESULT r = create_proxy( ProxyInfo->pDelegatedIIDs[Index], NULL, &This->base_proxy, (void **)&This->base_object ); if (FAILED(r)) { HeapFree( GetProcessHeap(), 0, This ); return r; } } *ppProxy = &This->IRpcProxyBuffer_iface; *ppvObj = &This->PVtbl; IUnknown_AddRef((IUnknown *)*ppvObj); IPSFactoryBuffer_AddRef(pPSFactory); TRACE( "iid=%s this %p proxy %p obj %p vtbl %p base proxy %p base obj %p\n", debugstr_guid(riid), This, *ppProxy, *ppvObj, This->PVtbl, This->base_proxy, This->base_object ); return S_OK; }
// Main int main(int argc, char **argv) { playerc_client_t *client; rtk_app_t *app; mainwnd_t *mainwnd; opt_t *opt; const char *host; int port; int i; int count; double rate; char section[256]; int device_count; device_t devices[PLAYER_MAX_DEVICES]; device_t *device; struct timeval tv, tc = {0, 0}; struct timespec st = {0, (1.0/GUI_UPDATE_RATE) * 1e9}; printf("PlayerViewer %s\n", PLAYER_VERSION); // Initialise rtk lib (after we have read the program options we // want). rtk_init(&argc, &argv); // Register signal handlers signal(SIGINT, sig_quit); signal(SIGQUIT, sig_quit); // Load program options opt = opt_init(argc, argv, NULL); if (!opt) { print_usage(); return -1; } // Pick out some important program options host = opt_get_string(opt, "", "host", NULL); if (!host) host = opt_get_string(opt, "", "h", "localhost"); port = opt_get_int(opt, "", "port", -1); if (port < 0) port = opt_get_int(opt, "", "p", 6665); rate = opt_get_double(opt, "", "rate", 5.0); if(rate < 0.0) rate = 0.0; // Connect to the server printf("Connecting to [%s:%d]\n", host, port); client = playerc_client_create(NULL, host, port); if (playerc_client_connect(client) != 0) { PRINT_ERR1("%s", playerc_error_str()); print_usage(); return -1; } if(rate == 0.0) { printf("Setting delivery mode to PLAYER_DATAMODE_PUSH\n"); // Change the server's data delivery mode. if (playerc_client_set_replace_rule(client, -1, -1, -1, -1, 0) != 0) { PRINT_ERR1("%s", playerc_error_str()); return -1; } // Change the server's data delivery mode. // PLAYERC_DATAMODE_PUSH, PLAYERC_DATAMODE_PULL if (playerc_client_datamode(client, PLAYERC_DATAMODE_PUSH) != 0) { PRINT_ERR1("%s", playerc_error_str()); return -1; } } // Get the available devices. if (playerc_client_get_devlist(client) != 0) { PRINT_ERR1("%s", playerc_error_str()); return -1; } // Create gui app = rtk_app_create(); // Create a window for most of the sensor data mainwnd = mainwnd_create(app, host, port); if (!mainwnd) return -1; // Create a list of available devices, with their gui proxies. device_count = 0; for (i = 0; i < client->devinfo_count; i++) { device = devices + device_count; device->addr = client->devinfos[i].addr; device->drivername = strdup(client->devinfos[i].drivername); // See if the device should be subscribed immediately. snprintf(section, sizeof(section), "%s:%d", interf_to_str(device->addr.interf), device->addr.index); device->subscribe = opt_get_int(opt, section, "", 0); device->subscribe = opt_get_int(opt, section, "subscribe", device->subscribe); if (device->addr.index == 0) { snprintf(section, sizeof(section), "%s", interf_to_str(device->addr.interf)); device->subscribe = opt_get_int(opt, section, "", device->subscribe); device->subscribe = opt_get_int(opt, section, "subscribe", device->subscribe); } // Allow for --position instead of --position2d if(device->addr.interf == PLAYER_POSITION2D_CODE) { snprintf(section, sizeof(section), "%s:%d", PLAYER_POSITION2D_STRING, device->addr.index); device->subscribe = opt_get_int(opt, section, "", device->subscribe); device->subscribe = opt_get_int(opt, section, "subscribe", device->subscribe); if (device->addr.index == 0) { snprintf(section, sizeof(section), "%s", PLAYER_POSITION2D_STRING); device->subscribe = opt_get_int(opt, section, "", device->subscribe); device->subscribe = opt_get_int(opt, section, "subscribe", device->subscribe); } } // Create the GUI proxy for this device. create_proxy(device, opt, mainwnd, client); device_count++; } // Print the list of available devices. printf("Available devices: %s:%d\n", host, port); for (i = 0; i < device_count; i++) { device = devices + i; snprintf(section, sizeof(section), "%s:%d", interf_to_str(device->addr.interf), device->addr.index); printf("%-16s %-40s", section, device->drivername); if (device->proxy) { if (device->subscribe) printf("subscribed"); else printf("ready"); } else printf("unsupported"); printf("\n"); } // Print out a list of unused options. opt_warn_unused(opt); // Start the gui; dont run in a separate thread and dont let it do // its own updates. rtk_app_main_init(app); // start out timer if in pull mode if(rate > 0.0) gettimeofday(&tv, NULL); while (!quit) { // Let gui process messages rtk_app_main_loop(app); if(rate == 0.0) // if we're in push mode { // see if there's data count = playerc_client_peek(client, 50); if (count < 0) { PRINT_ERR1("%s", playerc_error_str()); break; } if (count > 0) { /*proxy = */playerc_client_read_nonblock(client); } } else // we're in pull mode { // we only want to request new data at the target rate gettimeofday(&tc, NULL); if(((tc.tv_sec - tv.tv_sec) + (tc.tv_usec - tv.tv_usec)/1e6) > 1.0/rate) { tv = tc; // this requests a round of data from the server to be read playerc_client_requestdata(client); playerc_client_read_nonblock(client); } else { // sleep for the minimum time we can, so we don't use up too much // processor nanosleep(&st, NULL); } } // Update the devices for (i = 0; i < device_count; i++) { device = devices + i; if(device->proxy) (*(device->fnupdate)) (device->proxy); } // Update the main window if (mainwnd_update(mainwnd) != 0) break; } // Stop the gui rtk_app_main_term(app); // Destroy devices for (i = 0; i < device_count; i++) { device = devices + i; if (device->proxy) (*(device->fndestroy)) (device->proxy); free(device->drivername); } // Disconnect from server if (playerc_client_disconnect(client) != 0) { PRINT_ERR1("%s", playerc_error_str()); return -1; } playerc_client_destroy(client); // For some reason, either of the following calls makes the program // segfault on exit. I haven't figured out why, so I'm commenting them out. - BPG // Destroy the windows //mainwnd_destroy(mainwnd); // Destroy the gui //rtk_app_destroy(app); opt_term(opt); return 0; }