Esempio n. 1
0
static void client_event_cb(struct pomp_ctx *ctx, enum pomp_event event,
                struct pomp_conn *conn, const struct pomp_msg *msg,
                void *userdata)
{
  int fd, msgid;
  unsigned int bufsize;
  void *video_buffer;
  GstVideoFormat videoformat;
  unsigned int width, height;

  switch (event) {
    case POMP_EVENT_CONNECTED:
      ULOGI("connected to pimp user filter");
      break;
    case POMP_EVENT_DISCONNECTED:
      ULOGI("disconnected from pimp user filter");
      break;
    case POMP_EVENT_MSG:
      switch (msgid = pomp_msg_get_id(msg)) {
        case SEND_FD:
          pomp_msg_read(msg, "%x%u%u%u%u", &fd, &bufsize, &videoformat, &width, &height);
          ULOGI("received a FD from pimp: %d", fd);
          video_buffer = mmap(NULL, bufsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
          s_app.process(video_buffer, bufsize, videoformat, width, height, s_app.priv);
          pomp_ctx_send(ctx, BUFFER_PROCESSING_DONE, NULL);
          break;
        default:
          ULOGW("received unknown message id from pimp : %d", msgid);
          break;
      }
      break;
    default:
      ULOGE("Unknown event: %d", event);
      break;
  }
}
Esempio n. 2
0
static void test_ctx(const struct sockaddr *addr1, uint32_t addrlen1,
		const struct sockaddr *addr2, uint32_t addrlen2,
		int isdgram, int israw, int withsockcb, int withsendcb)
{
	int res = 0;
	struct test_data data;
	struct pomp_loop *loop = NULL;
	struct pomp_conn *conn = NULL;
	struct pomp_msg *msg = NULL;
	int fd = -1;
	uint32_t i = 0, j = 0;
	struct pomp_buffer *buf = NULL;

	memset(&data, 0, sizeof(data));
	data.isdgram = isdgram;
	data.israw = israw;
	data.srv.addr = addr1;
	data.srv.addrlen = addrlen1;
	data.cli.addr = addr2;
	data.cli.addrlen = addrlen2;
	msg = pomp_msg_new();
	CU_ASSERT_PTR_NOT_NULL_FATAL(msg);

	/* Create context */
	data.srv.ctx = pomp_ctx_new(&test_event_cb_t, &data);
	CU_ASSERT_PTR_NOT_NULL_FATAL(data.srv.ctx);
	if (israw) {
		res = pomp_ctx_set_raw(data.srv.ctx, &test_ctx_raw_cb);
		CU_ASSERT_EQUAL(res, 0);
	}
	if (withsockcb) {
		res = pomp_ctx_set_socket_cb(data.srv.ctx, &test_ctx_socket_cb);
		CU_ASSERT_EQUAL(res, 0);
	}
	if (withsendcb) {
		res = pomp_ctx_set_send_cb(data.srv.ctx, &test_ctx_send_cb);
		CU_ASSERT_EQUAL(res, 0);
	}

	/* Create context without callback */
	data.cli.ctx = pomp_ctx_new(NULL, &data);
	CU_ASSERT_PTR_NOT_NULL_FATAL(data.cli.ctx);
	res = pomp_ctx_destroy(data.cli.ctx);
	CU_ASSERT_EQUAL(res, 0);

	/* Invalid create (NULL 3nd arg) */
	data.cli.ctx = pomp_ctx_new_with_loop(NULL, &data, NULL);
	CU_ASSERT_PTR_NULL(data.cli.ctx);
	data.cli.ctx = pomp_ctx_new_with_loop(&test_event_cb_t, &data, NULL);
	CU_ASSERT_PTR_NULL(data.cli.ctx);

	/* Create 2nd context */
	data.cli.ctx = pomp_ctx_new(&test_event_cb_t, &data);
	CU_ASSERT_PTR_NOT_NULL_FATAL(data.cli.ctx);
	if (israw) {
		res = pomp_ctx_set_raw(data.cli.ctx, &test_ctx_raw_cb);
		CU_ASSERT_EQUAL(res, 0);
	}
	if (withsockcb) {
		res = pomp_ctx_set_socket_cb(data.cli.ctx, &test_ctx_socket_cb);
		CU_ASSERT_EQUAL(res, 0);
	}
	if (withsendcb) {
		res = pomp_ctx_set_send_cb(data.cli.ctx, &test_ctx_send_cb);
		CU_ASSERT_EQUAL(res, 0);
	}

	if (!isdgram) {
		/* Invalid start server (NULL param) */
		res = pomp_ctx_listen(NULL, addr1, addrlen1);
		CU_ASSERT_EQUAL(res, -EINVAL);
		res = pomp_ctx_listen(data.srv.ctx, NULL, addrlen1);
		CU_ASSERT_EQUAL(res, -EINVAL);

		/* Start as server 1st context */
		res = pomp_ctx_listen(data.srv.ctx, addr1, addrlen1);
		CU_ASSERT_EQUAL(res, 0);

		/* Invalid start server (busy) */
		res = pomp_ctx_listen(data.srv.ctx, addr1, addrlen1);
		CU_ASSERT_EQUAL(res, -EBUSY);
	} else {
		/* Invalid bind (NULL param) */
		res = pomp_ctx_bind(NULL, addr1, addrlen1);
		CU_ASSERT_EQUAL(res, -EINVAL);
		res = pomp_ctx_bind(data.srv.ctx, NULL, addrlen1);
		CU_ASSERT_EQUAL(res, -EINVAL);

		/* Bind 1st context */
		res = pomp_ctx_bind(data.srv.ctx, addr1, addrlen1);
		CU_ASSERT_EQUAL(res, 0);

		/* Invalid bind (busy) */
		res = pomp_ctx_bind(data.srv.ctx, addr1, addrlen1);
		CU_ASSERT_EQUAL(res, -EBUSY);
	}

	if (!isdgram) {
		/* Invalid start client (NULL param) */
		res = pomp_ctx_connect(NULL, addr2, addrlen2);
		CU_ASSERT_EQUAL(res, -EINVAL);
		res = pomp_ctx_connect(data.cli.ctx, NULL, addrlen2);
		CU_ASSERT_EQUAL(res, -EINVAL);

		/* Start as client 2nd context */
		res = pomp_ctx_connect(data.cli.ctx, addr2, addrlen2);
		CU_ASSERT_EQUAL(res, 0);

		/* Invalid start client (busy) */
		res = pomp_ctx_connect(data.cli.ctx, addr2, addrlen2);
		CU_ASSERT_EQUAL(res, -EBUSY);
	} else {
		/* Invalid bind (NULL param) */
		res = pomp_ctx_bind(NULL, addr2, addrlen2);
		CU_ASSERT_EQUAL(res, -EINVAL);
		res = pomp_ctx_bind(data.cli.ctx, NULL, addrlen2);
		CU_ASSERT_EQUAL(res, -EINVAL);

		/* Bind 2nd context */
		res = pomp_ctx_bind(data.cli.ctx, addr2, addrlen2);
		CU_ASSERT_EQUAL(res, 0);

		/* Invalid bind (busy) */
		res = pomp_ctx_bind(data.cli.ctx, addr2, addrlen2);
		CU_ASSERT_EQUAL(res, -EBUSY);
	}

	/* Invalid set raw */
	res = pomp_ctx_set_raw(NULL, &test_ctx_raw_cb);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_set_raw(data.srv.ctx, NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_set_raw(data.srv.ctx, &test_ctx_raw_cb);
	CU_ASSERT_EQUAL(res, -EBUSY);

	/* Invalid set socket cb */
	res = pomp_ctx_set_socket_cb(NULL, &test_ctx_socket_cb);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_set_socket_cb(data.srv.ctx, NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_set_socket_cb(data.srv.ctx, &test_ctx_socket_cb);
	CU_ASSERT_EQUAL(res, -EBUSY);

	/* Invalid set send cb */
	res = pomp_ctx_set_send_cb(NULL, &test_ctx_send_cb);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_set_send_cb(data.srv.ctx, NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);
	res = pomp_ctx_set_send_cb(data.srv.ctx, &test_ctx_send_cb);
	CU_ASSERT_EQUAL(res, -EBUSY);

	/* Invalid get loop (NULL param) */
	loop = pomp_ctx_get_loop(NULL);
	CU_ASSERT_PTR_NULL(loop);

	/* Invalid get fd (NULL param) */
	fd = pomp_ctx_get_fd(NULL);
	CU_ASSERT_EQUAL(fd, -EINVAL);

	/* Get loop and fd */
	loop = pomp_ctx_get_loop(data.srv.ctx);
	CU_ASSERT_PTR_NOT_NULL(loop);
	fd = pomp_ctx_get_fd(data.srv.ctx);
#ifdef POMP_HAVE_LOOP_EPOLL
	CU_ASSERT_TRUE(fd >= 0);
#else
	CU_ASSERT_EQUAL(fd, -ENOSYS);
#endif
	/* Invalid process fd (NULL param) */
	res = pomp_ctx_process_fd(NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);

	/* Keepalive settings */
	if (!isdgram) {
		/* TODO: check that it actually does something */
		res = pomp_ctx_setup_keepalive(data.srv.ctx, 0, 0, 0, 0);
		CU_ASSERT_EQUAL(res, 0);
		res = pomp_ctx_setup_keepalive(data.srv.ctx, 1, 5, 2, 1);
		CU_ASSERT_EQUAL(res, 0);
		res = pomp_ctx_setup_keepalive(NULL, 0, 0, 0, 0);
		CU_ASSERT_EQUAL(res, -EINVAL);
	}

	/* Run contexts (they shall connect each other) */
	run_ctx(data.srv.ctx, data.cli.ctx, 100);
	if (!isdgram) {
		CU_ASSERT_EQUAL(data.connection, 2);

		/* Get remote connections */
		conn = pomp_ctx_get_next_conn(data.srv.ctx, NULL);
		CU_ASSERT_PTR_NOT_NULL(conn);
		conn = pomp_ctx_get_next_conn(data.srv.ctx, conn);
		CU_ASSERT_PTR_NULL(conn);
		conn = pomp_ctx_get_conn(data.cli.ctx);
		CU_ASSERT_PTR_NOT_NULL(conn);

		/* Invalid get remote connections */
		conn = pomp_ctx_get_next_conn(data.cli.ctx, NULL);
		CU_ASSERT_PTR_NULL(conn);
		conn = pomp_ctx_get_conn(data.srv.ctx);
		CU_ASSERT_PTR_NULL(conn);
		conn = pomp_ctx_get_next_conn(NULL, NULL);
		CU_ASSERT_PTR_NULL(conn);
		conn = pomp_ctx_get_conn(NULL);
		CU_ASSERT_PTR_NULL(conn);
	}

	/* Exchange some message */
	if (!isdgram) {
		if (!israw) {
			res = pomp_ctx_send(data.srv.ctx, 1, "%s", "hello1->2");
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_ctx_send(data.cli.ctx, 1, "%s", "hello2->1");
			CU_ASSERT_EQUAL(res, 0);

			/* Invalid send (NULL param) */
			res = pomp_ctx_send(NULL, 1, "%s", "hello1->2");
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_ctx_send_msg(data.srv.ctx, NULL);
			CU_ASSERT_EQUAL(res, -EINVAL);

			/* Invalid send (bad format) */
			res = pomp_ctx_send(data.srv.ctx, 1, "%o", 1);
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_conn_send(pomp_ctx_get_conn(data.cli.ctx), 1, "%o", 1);
			CU_ASSERT_EQUAL(res, -EINVAL);

			/* Invalid send to (bad type) */
			res = pomp_ctx_send_msg_to(data.cli.ctx, msg, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);
		} else {
			buf = pomp_buffer_new(32);
			CU_ASSERT_PTR_NOT_NULL_FATAL(buf);
			memcpy(buf->data, "Hello World !!!", 15);
			buf->len = 15;

			res = pomp_ctx_send_raw_buf(data.srv.ctx, buf);
			data.datasent += 15;
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_ctx_send_raw_buf(data.cli.ctx, buf);
			data.datasent += 15;
			CU_ASSERT_EQUAL(res, 0);

			/* Invalid send (NULL param) */
			res = pomp_ctx_send_raw_buf(NULL, buf);
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_ctx_send_raw_buf(data.srv.ctx, NULL);
			CU_ASSERT_EQUAL(res, -EINVAL);

			pomp_buffer_unref(buf);
			buf = NULL;
		}
	} else {
		if (!israw) {
			res = pomp_msg_clear(msg);
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_msg_write(msg, 1, "%s", "hello1->2");
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_ctx_send_msg_to(data.srv.ctx, msg, addr2, addrlen2);
			CU_ASSERT_EQUAL(res, 0);

			res = pomp_msg_clear(msg);
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_msg_write(msg, 1, "%s", "hello2->1");
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_ctx_send_msg_to(data.cli.ctx, msg, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, 0);

			/* Invalid send (not connected) */
			res = pomp_ctx_send_msg(data.cli.ctx, msg);
			CU_ASSERT_EQUAL(res, -ENOTCONN);

			/* Invalid send to (NULL param) */
			res = pomp_ctx_send_msg_to(NULL, msg, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_ctx_send_msg_to(data.cli.ctx, NULL, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_ctx_send_msg_to(data.cli.ctx, msg, NULL, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);
		} else {
			buf = pomp_buffer_new(32);
			CU_ASSERT_PTR_NOT_NULL_FATAL(buf);
			memcpy(buf->data, "Hello World !!!", 15);
			buf->len = 15;

			res = pomp_ctx_send_raw_buf_to(data.srv.ctx, buf, addr2, addrlen2);
			CU_ASSERT_EQUAL(res, 0);
			data.datasent += 15;
			res = pomp_ctx_send_raw_buf_to(data.cli.ctx, buf, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, 0);
			data.datasent += 15;

			/* Invalid send (not connected) */
			res = pomp_ctx_send_raw_buf(data.cli.ctx, buf);
			CU_ASSERT_EQUAL(res, -ENOTCONN);

			/* Invalid send to (NULL param) */
			res = pomp_ctx_send_raw_buf_to(NULL, buf, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_ctx_send_raw_buf_to(data.cli.ctx, NULL, addr1, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);
			res = pomp_ctx_send_raw_buf_to(data.cli.ctx, buf, NULL, addrlen1);
			CU_ASSERT_EQUAL(res, -EINVAL);

			pomp_buffer_unref(buf);
			buf = NULL;
		}
	}

	/* Check no send callback directly called by the sending function. */
	CU_ASSERT_EQUAL(data.sendcount, 0);

	/* Run contexts (they shall have answered each other) */
	run_ctx(data.srv.ctx, data.cli.ctx, 100);
	if (!israw) {
		CU_ASSERT_EQUAL(data.msg, 4);
		if (withsendcb)
			CU_ASSERT_EQUAL(data.sendcount, 4);
	} else {
		if (data.isdgram)
			CU_ASSERT_EQUAL(data.buf, 2);
		CU_ASSERT_EQUAL(data.dataread, data.datasent);
		if (withsendcb)
			CU_ASSERT_EQUAL(data.sendcount, 2);
	}

	/* Dummy run */
	res = pomp_ctx_wait_and_process(data.srv.ctx, 100);
	CU_ASSERT_EQUAL(res, -ETIMEDOUT);
	res = pomp_ctx_wait_and_process(NULL, 100);
	CU_ASSERT_EQUAL(res, -EINVAL);

	/* Wakeup */
	res = pomp_ctx_wakeup(data.srv.ctx);
	CU_ASSERT_EQUAL(res, 0);
	res = pomp_ctx_wait_and_process(data.srv.ctx, 100);
	CU_ASSERT_EQUAL(res, 0);

	/* Invalid wakeup (NULL param) */
	res = pomp_ctx_wakeup(NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);

	/* Overflow server by writing on client side without running loop */
	if (!isdgram) {
		for (i = 0; i < 1024; i++) {
			if (buf == NULL)
				buf = pomp_buffer_new(1024);
			CU_ASSERT_PTR_NOT_NULL_FATAL(buf);
			for (j = 0; j < 1024; j++)
				buf->data[j] = rand() % 255;
			buf->len = 1024;

			if (!israw) {
				res = pomp_ctx_send(data.cli.ctx, 3, "%p%u", buf->data, 1024);
				CU_ASSERT_EQUAL(res, 0);
			} else {
				res = pomp_ctx_send_raw_buf(data.cli.ctx, buf);
				CU_ASSERT_EQUAL(res, 0);
			}

			if (buf->refcount > 1) {
				pomp_buffer_unref(buf);
				buf = NULL;
			}
		}
		if (buf != NULL) {
			pomp_buffer_unref(buf);
			buf = NULL;
		}

		/* Run contexts (to unlock writes) */
		run_ctx(data.srv.ctx, data.cli.ctx, 100);
		if (!israw)
			CU_ASSERT_EQUAL(data.msg, 4 + 1024);
	}

	/* Recursive send */
	if (withsendcb) {
		/* reset counts */
		data.buf = 0;
		data.msg = 0;
		data.sendcount = 0;
		data.datasent = 0;
		data.dataread = 0;

		/* Enable recursive send. */
		data.srv.recurs_send_enabled = 1;
		send_msg(&data, &data.srv, &data.cli, "srv_to_cli");

		/* Check no send callback directly called by the sending function. */
		CU_ASSERT_EQUAL(data.sendcount, 0);

		run_ctx(data.srv.ctx, data.cli.ctx, 100);

		if (!israw) {
			CU_ASSERT_EQUAL(data.msg, 2);
			CU_ASSERT_EQUAL(data.sendcount, 2);
		} else {
			if (data.isdgram)
				CU_ASSERT_EQUAL(data.buf, 2);
			CU_ASSERT_EQUAL(data.dataread, data.datasent);
			CU_ASSERT_EQUAL(data.sendcount, 2);
		}

		/* Check client recursive send during server disconnection */
		data.cli.recurs_send_enabled = 1;
		send_msg(&data, &data.cli, &data.srv, "cli_to_srv");
	}

	/* Disconnect client from server */
	if (!isdgram) {
		if (withsendcb) {
			/* Check recursive write during disconnection */
			data.srv.recurs_send_enabled = 1;
			data.isdisconnecting = 1;
		}

		res = pomp_conn_disconnect(pomp_ctx_get_next_conn(data.srv.ctx, NULL));
		CU_ASSERT_EQUAL(res, 0);

		/* Check recursive send callback by disconnection */
		if (withsendcb)
			CU_ASSERT_EQUAL(data.sendcount, 2);
	}

	/* Run contexts (they shall disconnect each other) */
	run_ctx(data.srv.ctx, data.cli.ctx, 100);
	pomp_ctx_process_fd(data.cli.ctx);
	if (!isdgram) {
		CU_ASSERT_EQUAL(data.disconnection, 2);

		if (!israw) {
			/* Invalid send (client not connected) */
			res = pomp_ctx_send(data.cli.ctx, 1, "%s", "hello2->1");
			CU_ASSERT_EQUAL(res, -ENOTCONN);
		} else {
			/* TODO */
		}
	}

	/* Invalid destroy (NULL param) */
	res = pomp_ctx_destroy(NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);

	/* Invalid destroy (busy) */
	res = pomp_ctx_destroy(data.srv.ctx);
	CU_ASSERT_EQUAL(res, -EBUSY);

	/* Stop server */
	res = pomp_ctx_stop(data.srv.ctx);
	CU_ASSERT_EQUAL(res, 0);

	/* Stop client */
	res = pomp_ctx_stop(data.cli.ctx);
	CU_ASSERT_EQUAL(res, 0);

	/* Invalid stop (NULL param) */
	res = pomp_ctx_stop(NULL);
	CU_ASSERT_EQUAL(res, -EINVAL);

	/* Stop when already done */
	res = pomp_ctx_stop(data.srv.ctx);
	CU_ASSERT_EQUAL(res, 0);

	/* Destroy contexts */
	res = pomp_ctx_destroy(data.srv.ctx);
	CU_ASSERT_EQUAL(res, 0);
	res = pomp_ctx_destroy(data.cli.ctx);
	CU_ASSERT_EQUAL(res, 0);

	res = pomp_msg_destroy(msg);
	CU_ASSERT_EQUAL(res, 0);
}
Esempio n. 3
0
static int send_msg(struct test_data *tdata, struct test_peer *src,
		struct test_peer *dst, char *msg)
{
	int res = 0;
	struct pomp_msg *pmsg = NULL;
	struct pomp_buffer *buf = NULL;

	/* Exchange some message */
	if (!tdata->isdgram) {
		if (!tdata->israw) {
			res = pomp_ctx_send(src->ctx, 3, "%s", msg);
		} else {
			buf = pomp_buffer_new(32);
			CU_ASSERT_PTR_NOT_NULL_FATAL(buf);
			memcpy(buf->data, msg, strlen(msg));
			buf->len = strlen(msg);

			res = pomp_ctx_send_raw_buf(src->ctx, buf);
			if (tdata->isdisconnecting && src == &tdata->cli) {
				/* Check failed if send after client disconnect */
				CU_ASSERT_EQUAL(res, -ENOTCONN);
			} else {
				tdata->datasent += strlen(msg);
				CU_ASSERT_EQUAL(res, 0);
			}

			pomp_buffer_unref(buf);
			buf = NULL;
		}
	} else {
		if (!tdata->israw) {
			pmsg = pomp_msg_new();
			res = pomp_msg_clear(pmsg);
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_msg_write(pmsg, 3, "%s", msg);
			CU_ASSERT_EQUAL(res, 0);
			res = pomp_ctx_send_msg_to(src->ctx, pmsg, dst->addr,
					dst->addrlen);
			if (tdata->isdisconnecting && src == &tdata->cli) {
				/* Check failed if send after client disconnect */
				CU_ASSERT_EQUAL(res, -ENOTCONN);
			} else {
				CU_ASSERT_EQUAL(res, 0);
			}

			res = pomp_msg_destroy(pmsg);
			CU_ASSERT_EQUAL(res, 0);
		} else {
			buf = pomp_buffer_new(32);
			CU_ASSERT_PTR_NOT_NULL_FATAL(buf);
			memcpy(buf->data, msg, strlen(msg));
			buf->len = strlen(msg);

			res = pomp_ctx_send_raw_buf_to(src->ctx, buf, dst->addr,
					dst->addrlen);
			if (tdata->isdisconnecting && src == &tdata->cli) {
				/* Check failed if send after client disconnect */
				CU_ASSERT_EQUAL(res, -ENOTCONN);
			} else {
				tdata->datasent += strlen(msg);
				CU_ASSERT_EQUAL(res, 0);
			}

			pomp_buffer_unref(buf);
			buf = NULL;
		}
	}

	return res;
}