Esempio n. 1
0
int
main()
{
	int mdp_sock;
	MSP_SOCKET msp_sock;
	struct mdp_sockaddr addr;
	struct sigaction act;
	struct timeval timeout;
 	time_ms_t now;
	time_ms_t next_time = 0;

	/* sample message to reply to clients */
	strcpy((char *)outbuf, "Hello World!");

	if ((mdp_sock = mdp_socket()) < 0) {
		std::cerr << "server: error creating mdp socket" << std::endl;
		return -1;
	}
	msp_sock = msp_socket(mdp_sock, 0);

	addr.sid = SID_ANY;
	addr.port = PORT;

	msp_set_local(msp_sock, &addr);
	msp_set_handler(msp_sock, listen_handler, NULL);
	msp_listen(msp_sock);
	if (!msp_socket_is_open(msp_sock)) {
		std::cerr << "server: error listening on msp socket" << std::endl;
		return -1;
	}

	/* cleanup on CTRL-C */
	memset(&act, 0, sizeof(act));
	act.sa_handler = &cleanup;
	if (sigaction(SIGINT, &act, NULL) < 0) {
		fprintf(stderr, "error registering signal handler\n");
		return -1;
	}

	/* main loop */
	std::cout << "server: starting server..." << std::endl;
	quit = 0;
	while (!quit) {
		now = gettime_ms();
		if (now < next_time) {
			struct timeval timeout = time_ms_to_timeval(next_time - now);
			setsockopt(mdp_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
			msp_recv(mdp_sock);
		}
		msp_processing(&next_time);
	}

	std::cout << "server: cleanup..." << std::endl;
	msp_close_all(mdp_sock);
	mdp_close(mdp_sock);

	return 0;
}
Esempio n. 2
0
// Function to check if a SID is reachable via MDP or MSP.
int _rpc_sid_is_reachable (sid_t sid) {
	// Create a MDP socket.
	int mdp_sockfd;
	if ((mdp_sockfd = mdp_socket()) < 0) {
		pfatal("Could not create MDP lookup socket. Aborting.");
		return -1;
	}

	// Init a mdp_frame
	overlay_mdp_frame mdp;
	bzero(&mdp,sizeof(mdp));

	// Set the packettype to get a routingtable.
	mdp.packetTypeAndFlags = MDP_ROUTING_TABLE;
	overlay_mdp_send(mdp_sockfd, &mdp, 0, 0);

	// Poll until there is nothing left.
	while (overlay_mdp_client_poll(mdp_sockfd, 200)) {
		// Create mdp_frame for incoming data. TTL is required but not needed...
		overlay_mdp_frame recv_frame;
		int ttl;
		if (overlay_mdp_recv(mdp_sockfd, &recv_frame, 0, &ttl)) {
      		continue;
  		}

		// Handle incoming data.
		int offset=0;
		while (offset + sizeof(struct overlay_route_record) <= recv_frame.out.payload_length) {
			// Make new route record struct where all needed information is stored in.
			struct overlay_route_record *record = &recv_frame.out.route_record;
			offset += sizeof(struct overlay_route_record);

			// If the record (aka SID) is reachable, and the record is the desired SID, return 1 and clean up.
			if ((record->reachable == REACHABLE_INDIRECT || record->reachable == REACHABLE_UNICAST || record->reachable == REACHABLE_BROADCAST || record->reachable == REACHABLE_SELF)
					&& !cmp_sid_t(&record->sid, &sid)) {
				mdp_close(mdp_sockfd);
				return 1;
			}
		}
	}
  mdp_close(mdp_sockfd);
  return 0;
}
long mdp_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
{
	int rc = 0;
	if (!sd) {
		WFD_MSG_ERR("Invalid arguments\n");
		return -EINVAL;
	}
	switch (cmd) {
	case MDP_Q_BUFFER:
		rc = mdp_q_buffer(sd, arg);
		break;
	case MDP_DQ_BUFFER:
		rc = mdp_dq_buffer(sd, arg);
		break;
	case MDP_OPEN:
		rc = mdp_open(sd, arg);
		break;
	case MDP_START:
		rc = mdp_start(sd, arg);
		break;
	case MDP_STOP:
		rc = mdp_stop(sd, arg);
		break;
	case MDP_SET_PROP:
		rc = mdp_set_prop(sd, arg);
		break;
	case MDP_CLOSE:
		rc = mdp_close(sd, arg);
		break;
	case MDP_MMAP:
		rc = mdp_mmap(sd, arg);
		break;
	case MDP_MUNMAP:
		rc = mdp_munmap(sd, arg);
		break;
	case MDP_SECURE:
		rc = mdp_secure(sd);
		break;
	default:
		WFD_MSG_ERR("IOCTL: %u not supported\n", cmd);
		rc = -EINVAL;
		break;
	}
	return rc;
}