C++ (Cpp) rpc_dispatch Examples

Example #1

File: rpc_unix.cpp Project: MaddTheSane/macemu

// Process incoming messages in the background
static void *rpc_server_func(void *arg)
{
  rpc_connection_t *connection = (rpc_connection_t *)arg;

  int ret = rpc_listen_socket(connection);
  if (ret < 0)
	return NULL;

  connection->server_thread_active = 1;
  for (;;) {
	// XXX broken MacOS X doesn't implement cancellation points correctly
	pthread_testcancel();

	// wait for data to arrive
	int ret = _rpc_wait_dispatch(connection, 50000);
	if (ret == 0)
	  continue;
	if (ret < 0)
	  break;

	rpc_dispatch(connection);
  }
  connection->server_thread_active = 0;
  return NULL;
}

Example #2

File: shell.cpp Project: pagxir/libflashcross

static LRESULT CALLBACK WndProc(HWND hWnd, UINT message,
	   	WPARAM wParam, LPARAM lParam)
{
	int fd, len;
	char buf[40960];
	int wmId, wmEvent;
	NPPlugin * plugin;

	switch (message) 
	{
		case WM_CREATE:
			SetWindowLong(hWnd, 0, 0);
			break;
		case WM_SIZE:
			plugin = (NPPlugin*)GetWindowLong(hWnd, 0);
			if (plugin != NULL)
			   	plugin->Resize(LOWORD(lParam), HIWORD(lParam));
			break;
			break;
		case WM_NETN:
			plugin_NetworkNotify(wParam, lParam);
			break;
		case WM_DEAE:
			len = recv(wParam, buf, sizeof buf, 0);
			if (len <= 0 || rpc_dispatch(wParam, buf, len) != 0)
				closesocket(wParam);
			break;
		case WM_DEAD:
			fd = accept(wParam, NULL, NULL);
			WSAAsyncSelect(fd, hWnd, WM_DEAE, FD_READ|FD_CLOSE);
			break;
		case WM_COMMAND:
			wmId    = LOWORD(wParam); 
			wmEvent = HIWORD(wParam); 
			switch (wmId)
			{
				case IDM_ABOUT:
					plugin = (NPPlugin*)GetWindowLong(hWnd, 0);
					if (plugin != NULL)
						plugin->AttachWindow();
					break;
				case IDM_EXIT:
					DestroyWindow(hWnd);
					break;
				default:
					return DefWindowProc(hWnd, message, wParam, lParam);
			}
			break;
		case WM_DESTROY:
			plugin = (NPPlugin*)GetWindowLong(hWnd, 0);
			if (plugin != NULL)
				plugin->DetachWindow();
			if (hWnd == __netscape_hwnd)
			   	PostQuitMessage(0);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

Example #3

File: test-rpc-common.c Project: davidben/nspluginwrapper

static gboolean
rpc_event_dispatch (GSource *source, GSourceFunc callback, gpointer user_data)
{
  gint rc;

  if (g_test.funcs.pre_dispatch_hook)
    {
      if (!g_test.funcs.pre_dispatch_hook (g_test.user_data))
	return TRUE;
    }

  rc = rpc_dispatch (g_connection);

  if (g_test.funcs.post_dispatch_hook)
    g_test.funcs.post_dispatch_hook (g_test.user_data);

  return rc != RPC_ERROR_CONNECTION_CLOSED;
}

Example #4

File: sec_rpc.c Project: tinocyngn/sofia-kernel

static int rpc_dispatcher_cmd(void *arg)
{
	struct t_rpc_dispatch *dispatch = (struct t_rpc_dispatch *)arg;
	struct t_rpc_cmd *cmd = (struct t_rpc_cmd *)&dispatch->cmd;
	struct t_rpc_param *param = (struct t_rpc_param *)&cmd->param;
	struct t_rpc_data *rpc_data;
	u8 *return_data = NULL;
	u32 return_data_len = 0;
	u32 result = 0;

	pr_debug("[sec_rpc] rpc_dispatcher_cmd: ACTION = %d\n", cmd->action);

	/* lock the list */
	if (down_interruptible(&data_list_sem)) {
		pr_err("[sec_rpc] rpc_dispatcher_cmd: Semaphore aquire interupted\n");
		return -ERESTARTSYS;
	}

	switch (cmd->action) {
	case RPC_ALLOC:
	{
		param->id = rpc_alloc_data(&g_data_list, param->length);
		if (param->id)
			cmd->result = RPC_SUCCESS;
		break;
	}
	case RPC_WRITE:
	{
		rpc_data = rpc_get_data(&g_data_list, param->id);
		if (rpc_data != NULL) {
			if ((param->length + param->offset) <=
			    rpc_data->length) {
				memcpy(&rpc_data->data[param->offset],
				       dispatch->data, param->length);
				cmd->result = RPC_SUCCESS;
			}
		}
		break;
	}
	case RPC_CALL:
	{
		rpc_data = rpc_get_data(&g_data_list, param->id);
		if (rpc_data != NULL)
			cmd->result = rpc_dispatch(param->if_grp,
						   param->opcode,
						   rpc_data->data,
						   &param->length);
		break;
	}
	case RPC_READ:
	{
		rpc_data = rpc_get_data(&g_data_list, param->id);
		if (rpc_data != NULL) {
			if (param->length + param->offset <= rpc_data->length) {
				return_data = &(rpc_data->data[param->offset]);
				return_data_len = param->length;
				cmd->result = RPC_SUCCESS;
			}
		}
		break;
	}
	case RPC_FREE:
	{
		cmd->result = rpc_free_data(&g_data_list, param->id);
		break;
	}
	case RPC_ALL:
	{
		cmd->result = rpc_dispatch(param->if_grp, param->opcode,
					   dispatch->data, &param->length);

		if (cmd->result == RPC_SUCCESS && 0 < param->length &&
			param->length <= param->buf_len) {
			return_data = dispatch->data;
			return_data_len = param->length;
		}
		break;
	}
	default:
	{
		break;
	}
	} /* end switch */

	up(&data_list_sem);

	if (cmd->result != RPC_SUCCESS) {
		pr_err("[sec_rpc] rpc_dispatcher_cmd: RPC cmd %d failed with result %d\n",
			cmd->action, cmd->result);
		cmd->result = RPC_FAILURE;
		result = -1;
	}

	cmd->action = RPC_DONE;
	result =
		(rpc_thread_tx(cmd, return_data, return_data_len, NULL, 0) ==
			RPC_SUCCESS ? 0 : -1);

	/* Free this thread and its associated data */
	if (dispatch != NULL) {
		if (dispatch->data != NULL)
			sec_rpc_free((void *)dispatch->data);
		sec_rpc_free((void *)dispatch);
	}

	return result;
}

Example #5

File: libp2p.c Project: buaaqbh/libraries

int p2p_dispatch(struct p2p *p2p)
{
    return rpc_dispatch(p2p->rpc);
}

Example #6

File: librpc.c Project: xia0Hong/libraries

static void *rpc_dispatch_thread(struct thread *t, void *arg)
{
    struct rpc *r = (struct rpc *)arg;
    rpc_dispatch(r);
    return NULL;
}