Exemple #1
0
	LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
		netPriv	*	priv;
		pixel_t	*	buffer;
		uint16_t	buf[5];
		coord_t		x, y;

		#if GDISP_DONT_WAIT_FOR_NET_DISPLAY
			if (!(g->flags & GDISP_FLG_CONNECTED))
				return;
		#else
			while(!(g->flags & GDISP_FLG_CONNECTED))
				gfxSleepMilliseconds(200);
		#endif

		// Make everything relative to the start of the line
		buffer = g->p.ptr;
		buffer += g->p.x2*g->p.y1;

		priv = g->priv;
		buf[0] = GNETCODE_BLIT;
		buf[1] = g->p.x;
		buf[2] = g->p.y;
		buf[3] = g->p.cx;
		buf[4] = g->p.cy;
		MUTEX_ENTER;
		sendpkt(priv->netfd, buf, 5);

		for(y = 0; y < g->p.cy; y++, buffer += g->p.x2 - g->p.cx) {
			for(x = 0; x < g->p.cx; x++, buffer++) {
				buf[0] = gdispColor2Native(buffer[0]);
				sendpkt(priv->netfd, buf, 1);
			}
		}
		MUTEX_EXIT;
	}
Exemple #2
0
	static DECLARE_THREAD_FUNCTION(NetThread, param) {
		GEventMouse				*pem;
		uint16_t				cmd[2];
		uint16_t				lbuttons;
		coord_t					lx, ly;
		(void)					param;

		// Initialize the mouse and the listener.
		geventListenerInit(&gl);
		geventAttachSource(&gl, ginputGetMouse(0), GLISTEN_MOUSEDOWNMOVES|GLISTEN_MOUSEMETA);
		lbuttons = 0;
		lx = ly = -1;

		while(1) {
			// Get a (mouse) event
			pem = (GEventMouse *)geventEventWait(&gl, TIME_INFINITE);
			if (pem->type != GEVENT_MOUSE && pem->type != GEVENT_TOUCH)
				continue;

			// Nothing to do if the socket is not open
			if (netfd == (SOCKET)-1)
				continue;

			// Nothing to do if the mouse data has not changed
			if (lx == pem->x && ly == pem->y && lbuttons == pem->current_buttons)
				continue;

			// Transfer mouse data that has changed
			if (lx != pem->x) {
				lx = pem->x;
				cmd[0] = GNETCODE_MOUSE_X;
				cmd[1] = lx;
				sendpkt(cmd, 2);
			}
			if (ly != pem->y) {
				ly = pem->y;
				cmd[0] = GNETCODE_MOUSE_Y;
				cmd[1] = ly;
				sendpkt(cmd, 2);
			}
			// We always send the buttons as it also acts as a mouse sync signal
			lbuttons = pem->current_buttons;
			cmd[0] = GNETCODE_MOUSE_B;
			cmd[1] = lbuttons;
			sendpkt(cmd, 2);
		}
		return 0;
	}
Exemple #3
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	int listenfd, connfd;
	int option = 1;
	struct sockaddr_in caddr, saddr;
	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
		printf("Listen is Wrong !!!!!!!\n");
		exit(2);
	}
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0){
		printf("Error!!!!!\n");
		exit(2);
	}

	memset(&saddr, 0, sizeof(saddr));
	saddr.sin_family = AF_INET;
	saddr.sin_addr.s_addr = htonl(INADDR_ANY);
	saddr.sin_port = htons(SON_PORT);
	bind(listenfd, (struct sockaddr*)&saddr, sizeof(saddr));
	listen(listenfd, 2);
	
	socklen_t len = sizeof(caddr);
	connfd = accept(listenfd, (struct sockaddr*)&caddr, &len);
	close(listenfd);
	
	sip_conn = connfd;
	sip_pkt_t* pkt = (sip_pkt_t *)malloc(sizeof(sip_pkt_t));
	int *nextNode = (int *)malloc(sizeof(int));
	while(1){
		if(getpktToSend(pkt, nextNode,sip_conn) > 0){
			if(*nextNode == BROADCAST_NODEID){
				int j = 0;
				while(j < neighNum){
					sendpkt(pkt, nt[j].conn);
					j ++;
				}
			}
			else{
				int j = 0;
				while(j < neighNum){
					if(*nextNode == nt[j].nodeID){
						sendpkt(pkt, nt[j].conn);
						j ++;
					}
				}
			}
		}
	}
}
Exemple #4
0
int main(int argc, char **argv) {
	char *ename = basename(argv[0]);

	uint8_t msg[PCKT_LEN];
	memset(msg, 0, sizeof msg);

	msg[0] = MODE_LOCK; // c**k blocked

	if(strcmp(ename, "lock") == 0) {
		msg[1] = LOCK_LOCKED;
	} else if(strcmp(ename, "unlock") == 0) {
		msg[1] = LOCK_UNLOCKED;
	} else {
		printf("have a nice day ;)\n");
		return 0;
	}	
	
	sendpkt(msg);

	time_t rightnow = time(NULL);
	struct tm *stamp = localtime(&rightnow);
	char timestamp[100]; // probably big enough...
	struct passwd *userentry = getpwuid(getuid());

	strftime(timestamp, sizeof timestamp, "%a %F %T", stamp);
	logline("%s := Door %s by %s\n", timestamp, msg[1] == LOCK_LOCKED ? "locked" : "unlocked", userentry->pw_name);
	
	return 0;
}
Exemple #5
0
	LLDSPEC	color_t gdisp_lld_get_pixel_color(GDisplay *g) {
		netPriv	*	priv;
		uint16_t	buf[3];
		color_t		data;

		#if GDISP_DONT_WAIT_FOR_NET_DISPLAY
			if (!(g->flags & GDISP_FLG_CONNECTED))
				return 0;
		#else
			while(!(g->flags & GDISP_FLG_CONNECTED))
				gfxSleepMilliseconds(200);
		#endif

		priv = g->priv;
		buf[0] = GNETCODE_READ;
		buf[1] = g->p.x;
		buf[2] = g->p.y;
		MUTEX_ENTER;
		sendpkt(priv->netfd, buf, 3);
		MUTEX_EXIT;

		// Now wait for a reply
		while(!(g->flags & GDISP_FLG_HAVEDATA) || priv->data[0] != GNETCODE_READ)
			gfxSleepMilliseconds(1);

		data = gdispNative2Color(priv->data[1]);
		g->flags &= ~GDISP_FLG_HAVEDATA;

		return data;
	}
Exemple #6
0
/*
 * Reset the network connection by sending an RST packet, print an error
 * message to standard output, and exit.
 */
void
reset(int fd)
{
	fprintf(stderr, "protocol error encountered... resetting connection\n");
	sendpkt(fd, RMTP_TYPE_RST, 0, 0, 0, 0);
	exit(0);
}
Exemple #7
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SON_PORT);

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    listen(listenfd, 20);

    sip_conn = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

    //recv pkt from sip and send
    sip_pkt_t pkt;
    int nextNode, conn;
    while(1){
        if(getpktToSend(&pkt,&nextNode,sip_conn) == 1){
            if (pkt.header.type == SIP){
                if((conn = getConnByID(nextNode)) >= 0){
                    if(sendpkt(&pkt,conn) < 0)
                        printf("Error in send pkt to Nbr\n");
                } else {
                    printf("Wrong Node id nextNode = %d\n",nextNode);
                }
            } else if (pkt.header.type == ROUTE_UPDATE){
                int nbr_num = topology_getNbrNum();
                int i;
                for (i = 0; i < nbr_num; i++){
                    if (nt[i].conn >= 0 && sendpkt(&pkt, nt[i].conn) < 0){
                        printf("Error in send route update pkt to Nbr\n");
                    }
                }
            }
        }
    }
    printf("Error in getpktToSend\n");
}
Exemple #8
0
//send out heartbeat (alive) messages to the tracker to keep its online status
void *Alive(void *arg)
{
	ptp_peer_t pkt;
	p2T_pkt_set(&pkt, 0, NULL, KEEP_ALIVE, NULL, myIP, PEER_PORT, 0, NULL);
	while (1) {
		sleep(ALIVE_INTERVAL);
		if (sendpkt(tracker_conn, &pkt) < 0) {
			printf("%s KEEP_ALIVE sending failed!\n", peer_trace);
			return NULL;
		}
	}
}
Exemple #9
0
// Sends a key/value pair out on the specified net socket.
// Accepts: file descriptor, key, value, length of value (needed because it might be binary)
// Returns: whether it was done sanely
bool hashhash::sendfile(int sfd, const char *filename, const char *data, size_t dlen) {
	// We should be careful; this is the maximum number of bytes we can have.
	int maxdatabytes = MAX_PACKET_LEN - 3;
	int numpkt = (int)ceil((double)dlen/maxdatabytes);
	int lastpkt = dlen % maxdatabytes;
	
	sendpkt(sfd, OPC_HRZ, filename, -1);
	
	for(int i = 0; i < numpkt; ++i) {
		int databytes = maxdatabytes;
		if(lastpkt != 0 && i == numpkt - 1) {
			databytes = lastpkt;
		}
		if(!sendpkt(sfd, OPC_STF, (data + i*maxdatabytes), databytes)) {
			return false;
		}
	}

	if(!sendpkt(sfd, OPC_STF, NULL, 0))
		return false;
	
	return true;
}
Exemple #10
0
	LLDSPEC void gdisp_lld_flush(GDisplay *g) {
		netPriv	*	priv;
		uint16_t	buf[1];

		#if GDISP_DONT_WAIT_FOR_NET_DISPLAY
			if (!(g->flags & GDISP_FLG_CONNECTED))
				return;
		#else
			while(!(g->flags & GDISP_FLG_CONNECTED))
				gfxSleepMilliseconds(200);
		#endif

		priv = g->priv;
		buf[0] = GNETCODE_FLUSH;
		MUTEX_ENTER;
		sendpkt(priv->netfd, buf, 1);
		MUTEX_EXIT;
	}
Exemple #11
0
	LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
		netPriv	*	priv;
		uint16_t	buf[4];

		#if GDISP_DONT_WAIT_FOR_NET_DISPLAY
			if (!(g->flags & GDISP_FLG_CONNECTED))
				return;
		#else
			while(!(g->flags & GDISP_FLG_CONNECTED))
				gfxSleepMilliseconds(200);
		#endif

		priv = g->priv;
		buf[0] = GNETCODE_PIXEL;
		buf[1] = g->p.x;
		buf[2] = g->p.y;
		buf[3] = gdispColor2Native(g->p.color);
		MUTEX_ENTER;
		sendpkt(priv->netfd, buf, 4);
		MUTEX_EXIT;
	}
Exemple #12
0
/*
** xmt()
*/
void
xmt(
	xmt_ctx *	xctx
	)
{
	SOCKET		sock = xctx->sock;
	struct dns_ctx *dctx = xctx->spkt->dctx;
	sent_pkt *	spkt = xctx->spkt;
	sockaddr_u *	dst = &spkt->addr;
	struct timeval	tv_xmt;
	struct pkt	x_pkt;
	size_t		pkt_len;
	int		sent;

	if (0 != gettimeofday(&tv_xmt, NULL)) {
		msyslog(LOG_ERR,
			"xmt: gettimeofday() failed: %m");
		exit(1);
	}
	tv_xmt.tv_sec += JAN_1970;

	pkt_len = generate_pkt(&x_pkt, &tv_xmt, dctx->key_id,
			       dctx->key);

	sent = sendpkt(sock, dst, &x_pkt, pkt_len);
	if (sent) {
		/* Save the packet we sent... */
		memcpy(&spkt->x_pkt, &x_pkt, min(sizeof(spkt->x_pkt),
		       pkt_len));
		spkt->stime = tv_xmt.tv_sec - JAN_1970;

		TRACE(2, ("xmt: %lx.%6.6u %s %s\n", (u_long)tv_xmt.tv_sec,
			  (u_int)tv_xmt.tv_usec, dctx->name, stoa(dst)));
	} else {
		dec_pending_ntp(dctx->name, dst);
	}

	return;
}
Exemple #13
0
	LLDSPEC void gdisp_lld_vertical_scroll(GDisplay *g) {
		netPriv	*	priv;
		uint16_t	buf[6];

		#if GDISP_DONT_WAIT_FOR_NET_DISPLAY
			if (!(g->flags & GDISP_FLG_CONNECTED))
				return;
		#else
			while(!(g->flags & GDISP_FLG_CONNECTED))
				gfxSleepMilliseconds(200);
		#endif

		priv = g->priv;
		buf[0] = GNETCODE_SCROLL;
		buf[1] = g->p.x;
		buf[2] = g->p.y;
		buf[3] = g->p.cx;
		buf[4] = g->p.cy;
		buf[5] = g->p.y1;
		MUTEX_ENTER;
		sendpkt(priv->netfd, buf, 6);
		MUTEX_EXIT;
	}
Exemple #14
0
static event_t *
get_packet_v(rtmp_t *r, uint8_t *data, int size, int64_t dts,
	     media_pipe_t *mp)
{
  uint8_t flags;
  uint8_t type = 0;
  enum AVCodecID id;
  int d = 0;
  event_t *e;

  if(r->r->m_read.flags & RTMP_READ_SEEKING)
    return NULL; 

  if(size < 2)
    return NULL;

  flags = *data++;
  size--;


  switch(flags & 0xf) {
  case 7:
    type = *data++;
    size--;
    id = AV_CODEC_ID_H264;

    if(size < 3)
      return NULL;
    
    d = (AMF_DecodeInt24((char *)data) + 0xff800000) ^ 0xff800000;
    data += 3;
    size -= 3;
    break;

  case 4:
    type = *data++;
    size--;
    id = AV_CODEC_ID_VP6F;
    break;
  default:
    return NULL;
  }

  if(r->vcodec == NULL) {
    media_codec_params_t mcp = {0};

    switch(id) {
    case AV_CODEC_ID_H264:
      if(type != 0 || size < 0)
	return NULL;

      mcp.extradata      = data;
      mcp.extradata_size = size;
      break;

    case AV_CODEC_ID_VP6F:
      if(size < 1)
	return NULL;
      mcp.extradata      = data;
      mcp.extradata_size = size;
      break;

    default:
      abort();
    }
    mcp.width = r->width;
    mcp.height = r->height;
    r->vcodec = media_codec_create(id, 0, NULL, NULL, &mcp, mp);
    return NULL;
  }


  int skip = 0;

  //  r->last_video_dts = dts;

  int64_t pts = 1000LL * (dts + d);
  dts = 1000LL * dts;

  if(d < 0 || dts <= r->seekpos_video) {
    skip = 1;
    r->in_seek_skip = 1;
  } else if(r->in_seek_skip) {
    skip = 2;
    r->in_seek_skip = 0;
  } else {
    r->seekpos_video = dts;
  }

  e = sendpkt(r, &r->mp->mp_video, r->vcodec, dts, pts,
	      data, size, skip, MB_VIDEO, r->vframeduration, 1);
  return e;
}
Exemple #15
0
/* The heart of (S)NTP, exchange NTP packets and compute values to correct the local clock */
int
on_wire (
	struct addrinfo *host,
	struct addrinfo *bcast
	)
{
	char addr_buf[INET6_ADDRSTRLEN];
	register int try;
	SOCKET sock;
	struct key *pkt_key = NULL;
	int key_id = 0;
	struct timeval tv_xmt;
	struct pkt x_pkt;
	int error, rpktl, handle_pkt_res;


	if (ENABLED_OPT(AUTHENTICATION)) {
		key_id = (int) atol(OPT_ARG(AUTHENTICATION));
		get_key(key_id, &pkt_key);
	}
	for (try=0; try<5; try++) {
		memset(&r_pkt, 0, sizeof rbuf);
		
		error = GETTIMEOFDAY(&tv_xmt, (struct timezone *)NULL);
		tv_xmt.tv_sec += JAN_1970;

#ifdef DEBUG
		printf("sntp on_wire: Current time sec: %i msec: %i\n", (unsigned int) tv_xmt.tv_sec, 
				(unsigned int) tv_xmt.tv_usec);
#endif

		if (bcast) {
			create_socket(&sock, (sockaddr_u *)bcast->ai_addr);
			rpktl = recv_bcst_pkt(sock, &r_pkt, sizeof rbuf, (sockaddr_u *)bcast->ai_addr);
			closesocket(sock);
		} else {
			int pkt_len = generate_pkt(&x_pkt, &tv_xmt, key_id, pkt_key);

			create_socket(&sock, (sockaddr_u *)host->ai_addr);
			sendpkt(sock, (sockaddr_u *)host->ai_addr, &x_pkt, pkt_len);
			rpktl = recvpkt(sock, &r_pkt, sizeof rbuf, &x_pkt);
			closesocket(sock);
		}

		handle_pkt_res = handle_pkt(rpktl, &r_pkt, host);
		if (handle_pkt_res < 1)
			return handle_pkt_res;
	}

	getnameinfo(host->ai_addr, host->ai_addrlen, addr_buf, sizeof(addr_buf), NULL, 0, NI_NUMERICHOST);
	msyslog(LOG_DEBUG, "Received no useable packet from %s!", addr_buf);

	return -1;
}

/* Compute the 8 bits for li_vn_mode */
void
set_li_vn_mode (
	struct pkt *spkt,
	char leap,
	char version,
	char mode
	) 
{
	if (leap > 3) {
		msyslog(LOG_DEBUG, "set_li_vn_mode: leap > 3 using max. 3");
		leap = 3;
	}

	if (mode > 7) {
		msyslog(LOG_DEBUG, "set_li_vn_mode: mode > 7, using client mode 3");
		mode = 3;
	}

	spkt->li_vn_mode  = leap << 6;
	spkt->li_vn_mode |= version << 3;
	spkt->li_vn_mode |= mode;
}

/* set_time corrects the local clock by offset with either settimeofday() or by default 
 * with adjtime()/adjusttimeofday().
 */
int
set_time(
	double offset
	)
{
	struct timeval tp;

	if (ENABLED_OPT(SETTOD)) {
		GETTIMEOFDAY(&tp, NULL);

		tp.tv_sec += (long)offset;
		tp.tv_usec += 1e6 * (offset - (long)offset);
		NORMALIZE_TIMEVAL(tp);

		if (SETTIMEOFDAY(&tp, NULL) < 0) {
			msyslog(LOG_ERR, "Time not set: settimeofday(): %m");
			return -1;
		}
		return 0;
	}

	tp.tv_sec = (long)offset;
	tp.tv_usec = 1e6 * (offset - (long)offset);
	NORMALIZE_TIMEVAL(tp);

	if (ADJTIMEOFDAY(&tp, NULL) < 0) {
		msyslog(LOG_ERR, "Time not set: adjtime(): %m");
		return -1;
	}
	return 0;
}
main(int argc, char *argv[]) {
	setbuf(stdout, NULL);
	int sock;

	// check usage
	if (argc != 4) {
		fprintf(stderr, "usage : %s <username> <server_ip_address> <5945>\n", argv[0]);
		exit(1);
	}

	// get hooked on to the server
	sock = hooktoserver(argv[1], argv[2], atoi(argv[3]));

	if (sock == -1)
		exit(1);

	fflush(stdout);

	// Initialize FDs to zero.
	// Assign Input FD to client Fds.
	// Assign socked FD to client Fds.

	fd_set clientfds, tempfds;
	FD_ZERO(&clientfds);
	FD_ZERO(&tempfds);
	FD_SET(sock, &clientfds);
	FD_SET(0, &clientfds);

	while (1) {

		// Use tempfds as it will be overwritten on select call
		// We want clientfds to keep track of all connected fds.

		tempfds = clientfds;

		if (select(FD_SETSIZE, &tempfds, NULL, NULL, NULL) == -1) {
			perror("select");
			exit(4);
		}

		// For every fd in the list, if the fd is set, check if
		// that is socket fd. If so, then it means that it we
		// received some message from server. It can be a message
		// from different client or server death. Also if the fd
		// is 0, it means there is some input from the user.
		// Read that input and send it to the server.

		int fd;
		for (fd = 0; fd < FD_SETSIZE; fd++) {
			if (FD_ISSET(fd,&tempfds)) {
				if (fd == sock) {
					Packet *pkt;
					pkt = recvpkt(sock);
					if (!pkt) {

						// server killed, exit
						fprintf(stderr, "Server closed the connection.\n");
						exit(1);
					}

					// display the text
					if (pkt->type == EMAIL_MSG_TO_CLIENT) {
						printf("New email received !\n>> %s\n", pkt->text);
					}else if(pkt->type == WELCOME_MSG){

						// Received welcome message. Print it.
						printf(">> %s\n", pkt->text);

						// Send username to client.
						char msg[MAXMSGLEN];
						strcpy(msg, argv[1]);

						// fprintf(stderr, "user: %s", msg);
						sendpkt(sock, USER_NAME, strlen(msg) + 1, msg);

					}else if(pkt->type == SERVER_ERROR) {

						printf(">> %s\n", pkt->text);
					}
					else{
						fprintf(stderr, "error: unexpected reply from server\n");
						exit(1);
					}

					// free the message
					freepkt(pkt);
				}

				if (fd == 0) {
					char msg[MAXMSGLEN];

					if (!fgets(msg, MAXMSGLEN, stdin))
						exit(0);

					if (strncmp(msg, QUIT_STRING, strlen(QUIT_STRING)) == 0) {
						sendpkt(sock, CLOSE_CON, 0, NULL);
						break;
					}

					char * pch1, *pch2, *user, *ipaddr;
					pch1 = strstr(msg, " ");
					pch2 = strstr(msg, "@");

					if (pch1 == NULL || pch2 == NULL) {
						fprintf(stderr,
								"error: invalid e-mail format.\nsyntax: <recp_user>@<ip_addr> <mesg>\n");
						break;
					}

					if (pch1 < pch2)
					{
						fprintf(stderr, "error: user name cannot contain spaces.\n");
						fprintf(stderr,
								"error: invalid e-mail format.\nsyntax: <recp_user>@<ip_addr> <mesg>\n");
						break;
					}

					user = (char *) malloc((strlen(msg) - strlen(pch2) + 1)*sizeof(char));
					strncpy(user, msg, (strlen(msg) - strlen(pch2))*sizeof(char));
					user[strlen(msg) - strlen(pch2)] = '\0';

					// fprintf(stderr, "client: user: %s", user);

					if(strcmp(user,"") == 0)
					{
						fprintf(stderr, "error: no username entered.\n");
						free(user);
						break;
					}

					ipaddr = (char *) malloc(
							(strlen(pch2) - strlen(pch1))* sizeof(char));
					strncpy(ipaddr, msg + strlen(user) + 1,
							(strlen(pch2) - strlen(pch1) - 1) * sizeof(char));
					ipaddr[strlen(pch2) - strlen(pch1) - 1] = '\0';

					// fprintf(stderr, "server: ip: %s", ipaddr);

					struct sockaddr_in sa;
					int result = inet_pton(AF_INET, ipaddr, &(sa.sin_addr));
					if(result == 0){
						fprintf(stderr,
								"error: invalid ip-address format.\nsyntax: <recp_user>@<ip_addr> <mesg>\n");
						free(user);
						free(ipaddr);
						break;
					}

					char * mailmsg;
					mailmsg = (char *) malloc(strlen(pch1) * sizeof(char));
					strncpy(mailmsg,
							msg + strlen(user) + strlen(ipaddr) + 2,
							(strlen(pch1) - 1) * sizeof(char));
					mailmsg[strlen(pch1)-1] = '\0';

					// It is okay to have empty body in the email message.

					if(strlen(mailmsg) > 80)
					{
						fprintf(stderr, "error: mail message length can be atmost 80 characters.\n");
						free(user);
						free(ipaddr);
						free(mailmsg);
						break;
					}

					// fprintf(stderr, "server: mailmsg: %s", mailmsg);

					free(user);
					free(ipaddr);
					free(mailmsg);

					msg[strlen(msg) - 1] = '\0';
					sendpkt(sock, EMAIL_MSG_TO_SERVER, strlen(msg) + 1, msg);

				}
			}
		}
	}
}
Exemple #17
0
/*
 * sendrequest - format and send a request packet
 *
 * Historically, ntpdc has used a fixed-size request packet regardless
 * of the actual payload size.  When authenticating, the timestamp, key
 * ID, and digest have been placed just before the end of the packet.
 * With the introduction in late 2009 of support for authenticated
 * ntpdc requests using larger 20-octet digests (vs. 16 for MD5), we
 * come up four bytes short.
 *
 * To maintain interop while allowing for larger digests, the behavior
 * is unchanged when using 16-octet digests.  For larger digests, the
 * timestamp, key ID, and digest are placed immediately following the
 * request payload, with the overall packet size variable.  ntpd can
 * distinguish 16-octet digests by the overall request size being
 * REQ_LEN_NOMAC + 4 + 16 with the auth bit enabled.  When using a
 * longer digest, that request size should be avoided.
 *
 * With the form used with 20-octet and larger digests, the timestamp,
 * key ID, and digest are located by ntpd relative to the start of the
 * packet, and the size of the digest is then implied by the packet
 * size.
 */
static int
sendrequest(
	int implcode,
	int reqcode,
	int auth,
	u_int qitems,
	size_t qsize,
	char *qdata
	)
{
	struct req_pkt qpkt;
	size_t	datasize;
	size_t	reqsize;
	u_long	key_id;
	l_fp	ts;
	l_fp *	ptstamp;
	int	maclen;
	char *	pass;

	memset(&qpkt, 0, sizeof(qpkt));

	qpkt.rm_vn_mode = RM_VN_MODE(0, 0, 0);
	qpkt.implementation = (u_char)implcode;
	qpkt.request = (u_char)reqcode;

	datasize = qitems * qsize;
	if (datasize && qdata != NULL) {
		memcpy(qpkt.data, qdata, datasize);
		qpkt.err_nitems = ERR_NITEMS(0, qitems);
		qpkt.mbz_itemsize = MBZ_ITEMSIZE(qsize);
	} else {
		qpkt.err_nitems = ERR_NITEMS(0, 0);
		qpkt.mbz_itemsize = MBZ_ITEMSIZE(qsize);  /* allow for optional first item */
	}

	if (!auth || (keyid_entered && info_auth_keyid == 0)) {
		qpkt.auth_seq = AUTH_SEQ(0, 0);
		return sendpkt(&qpkt, req_pkt_size);
	}

	if (info_auth_keyid == 0) {
		key_id = getkeyid("Keyid: ");
		if (!key_id) {
			fprintf(stderr, "Invalid key identifier\n");
			return 1;
		}
		info_auth_keyid = key_id;
	}
	if (!authistrusted(info_auth_keyid)) {
		pass = getpass_keytype(info_auth_keytype);
		if ('\0' == pass[0]) {
			fprintf(stderr, "Invalid password\n");
			return 1;
		}
		authusekey(info_auth_keyid, info_auth_keytype,
			   (u_char *)pass);
		authtrust(info_auth_keyid, 1);
	}
	qpkt.auth_seq = AUTH_SEQ(1, 0);
	if (info_auth_hashlen > 16) {
		/*
		 * Only ntpd which expects REQ_LEN_NOMAC plus maclen
		 * octets in an authenticated request using a 16 octet
		 * digest (that is, a newer ntpd) will handle digests
		 * larger than 16 octets, so for longer digests, do
		 * not attempt to shorten the requests for downlevel
		 * ntpd compatibility.
		 */
		if (REQ_LEN_NOMAC != req_pkt_size)
			return 1;
		reqsize = REQ_LEN_HDR + datasize + sizeof(*ptstamp);
		/* align to 32 bits */
		reqsize = (reqsize + 3) & ~3;
	} else
		reqsize = req_pkt_size;
	ptstamp = (void *)((char *)&qpkt + reqsize);
	ptstamp--;
	get_systime(&ts);
	L_ADD(&ts, &delay_time);
	HTONL_FP(&ts, ptstamp);
	maclen = authencrypt(info_auth_keyid, (void *)&qpkt, reqsize);
	if (!maclen) {  
		fprintf(stderr, "Key not found\n");
		return 1;
	} else if (maclen != (info_auth_hashlen + sizeof(keyid_t))) {
		fprintf(stderr,
			"%d octet MAC, %lu expected with %lu octet digest\n",
			maclen, (u_long)(info_auth_hashlen + sizeof(keyid_t)),
			(u_long)info_auth_hashlen);
		return 1;
	}
	return sendpkt(&qpkt, reqsize + maclen);
}
Exemple #18
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	int listenfd;
	socklen_t clilen;
	clilen = sizeof(struct sockaddr_in);
	struct sockaddr_in cliaddr, servaddr;
	memset(&cliaddr, 0, sizeof(cliaddr));
	memset(&servaddr, 0, sizeof(servaddr));

	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	
	servaddr.sin_family = AF_INET;
	// servaddr.sin_addr.s_addr = INADDR_ANY;
	inet_aton("127.0.0.1", &servaddr.sin_addr);
	servaddr.sin_port = htons(SON_PORT);

	const int on = 1;
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(const int));
	bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	listen(listenfd, MAX_NODE_NUM);

	while (1) {
		// wait for sip connection
		memset(&cliaddr, 0, sizeof(struct sockaddr));
		sip_conn = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
		if (sip_conn == -1) {
			print_pos();
			printf("ERROR: accept sip connection failed\n");
			sleep(1);
			continue;
		}

		/* recv from sip and son forward start here */
//		print_pos();
//		printf("MSG: sip access ok, sip_conn = %d, begin to convey sip->son\n", sip_conn);
		sip_pkt_t tmp;
		int nNode, result;
		while (1){
			memset(&tmp, 0, sizeof(sip_pkt_t));
			result = getpktToSend(&tmp, &nNode, sip_conn);
			if(result == -1) {
				print_pos();
				printf("ERROR: get pkt from sip failed\nMSG: Break loop wait another sip connect\n");
				sleep(1);
				break;
			}
			// print_pos();
			// printf("MSG: get sip_pkt_t to send ok, send to nbr...\n");
			// if broad cast, send to every neighbor
			if (nNode == BROADCAST_NODEID){
				int ct = topology_getNbrNum();
				int i;
				for (i = 0; i < ct; i++){
					// print_pos();
					// printf("MSG: broadcast send to socket %d\n", nt[i].conn);
					result = sendpkt(&tmp, nt[i].conn);
					if (result == -1){
						print_pos();
						printf("ERROR: send pkt to broadcast failed\n");
						continue;
					}
				}
//				printf("MSG: send sip_pkt_t to broadcast ok\n");
			} else{	// others, send to next hop
				int destConn = getConnByNode(nNode);
				if (destConn == -1) {
					print_pos();
					printf("ERROR: conn not set up\n");
				}
				result = sendpkt(&tmp, destConn);
				if (result == -1){
					printf("ERROR: send pkt to next node failed\n");
					continue;
				}
//				printf("MSG: send sip_pkt_t to nbr ok, socket=%d\n", destConn);
			}
		}
	}
}
Exemple #19
0
//monitor a local file directory; send out updated file table to the tracker if any file changes in the local file directory
void *FileMonitor(void *arg)
{
	ptp_peer_t pkt;
	p2T_pkt_set(&pkt, 0, NULL, FILE_UPDATE, NULL, myIP, PEER_PORT, 0, NULL);

	//monitor a local file directory
	int fd;
	int wd;
	char buffer[BUF_LEN];
	
	fd = inotify_init();
	
	if (fd < 0) {
		perror("inotify_init");
	}
	
	wd = inotify_add_watch(fd, ".", IN_MODIFY | IN_CREATE | IN_DELETE | IN_CLOSE_WRITE | IN_DELETE_SELF);

	int state = 0;
	
	int out = 0;
	while (out == 0) {
		int i = 0;
		int length = read(fd, buffer, BUF_LEN);  
 		if (length < 0) {
  			perror("read");
		}
  		while (i < length) {
			struct inotify_event *event = (struct inotify_event *) &buffer[ i ];
			if (event->len && event->name[0] != '.') {
				if (event->mask & IN_DELETE_SELF) {
					out = 1;
					break;
				}
				else if (event->mask & IN_DELETE) {
					pthread_mutex_lock(peer_file_table_mutex);
					if (event->mask & IN_ISDIR) {
						printf("The directory %s was deleted.\n", event->name);       
					}
					else {
						printf("The file %s was deleted.\n", event->name);
					}
					
					filenode *p = fileTable_Exist(file_table, event->name, myIP);
					if (p != NULL) {
						// if the file is still in the table, that means the peer itself delete it instead of the tracker told it to
						fileTable_Delete(event->name, myIP);
						// then we need to send the updated table to the tracker
						if (sendpkt(tracker_conn, &pkt) < 0) {
							printf("%s updated local file table sending failed!\n", peer_trace);
							return NULL;
						}
						
					}
					pthread_mutex_unlock(peer_file_table_mutex);
				}
				else if (event->mask & IN_CREATE) {
					state = 2;
					//printf("create %s\n", event->name);
				}
				else if (event->mask & IN_MODIFY) {
					//printf("modify %s\n", event->name);
					if (state == 0) {
						state = 1;
					}
					
				}
				else if (event->mask & IN_CLOSE_WRITE) {
					//printf("close write %s\n", event->name);
					pthread_mutex_lock(peer_file_table_mutex);
					if (state == 2) {
						if (event->mask & IN_ISDIR) {
							printf("The directory %s was created.\n", event->name);       
						}
						else {
							printf("The file %s was created.\n", event->name);
						}

						filenode tmp;
						memset(&tmp, 0, sizeof(filenode));
						strcpy(tmp.filename, event->name);
						tmp.filesize = getFileSize(tmp.filename);
						if (tmp.filesize < 0) {
							state = 0;
							pthread_mutex_unlock(peer_file_table_mutex);
							continue;
						}
						tmp.timestamp = 0;
						strcpy(tmp.peerIP, myIP);

						// try to add this node into the local file table
						// if there's already such a node in the table, that means this file is downloaded
						// otherwise it's created
						
						filenode* p = fileTable_Exist(file_table, event->name, NULL);
						if (p == NULL) {
							// locally created a file
							fileTable_Add(&tmp, myIP);
						}
						else {
							if (strcmp(p->peerIP, myIP) != 0) {
								// newly downloaded
								strcpy(p->peerIP, myIP);
							}
							else {
								// vim version update
								p->filesize = getFileSize(event->name);
								p->timestamp = 0;
							}
						}
						printf("%s Updated local file table:\n", peer_trace);
						fileTable_Print(file_table);

						// either way we should send the updated table to the tracker
						if (sendpkt(tracker_conn, &pkt) < 0) {
							printf("%s updated local file table sending failed!\n", peer_trace);
							return NULL;
							
						}
					}
					else if (state == 1) {
						if (event->mask & IN_ISDIR) {
							printf("The directory %s was modified.\n", event->name);
						}
						else {
							printf("The file %s was modified.\n", event->name);
						}

						filenode *p = fileTable_Exist(file_table, event->name, NULL);
						if (p != NULL) {
							if (strcmp(p->peerIP, myIP) == 0) {
								// the file is modified locally, reset the size and the timestamp and send to the tracker
								p->filesize = getFileSize(event->name);
								p->timestamp = 0;
							}
							else {
								strcpy(p->peerIP, myIP);
							}
							printf("%s Updated local file table:\n", peer_trace);
							fileTable_Print(file_table);
							if (sendpkt(tracker_conn, &pkt) < 0) {
								printf("%s updated local file table sending failed!\n", peer_trace);
								return NULL;
							}
						}
						else {
							printf("I should not be here!\n");
						}
					}
					state = 0;
					pthread_mutex_unlock(peer_file_table_mutex);
				}
			}
			i += EVENT_SIZE + event->len;
		}
	}

	(void) inotify_rm_watch(fd, wd);
	(void) close(fd);
	exit(0);
}
Exemple #20
0
void peer_main()
{
	// initialize the tables
	tracker_conn = -1;
	fileTable_Initialize();
	peerpeerTable_Initialize();

	// initialize the mutex
	peer_file_table_mutex	= (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
	peer_peer_table_mutex	= (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
	pthread_mutex_init(peer_file_table_mutex, NULL);
	pthread_mutex_init(peer_peer_table_mutex, NULL);

	//register peer_stop
	signal(SIGINT,peer_stop);

	myIP = my_ip();
	printf("%s Local ip address is %s\n", peer_trace, myIP);

	// try to connect to the tracker
	tracker_conn = connectToTracker();
	if (-1 == tracker_conn) {
		printf("%s Can't connect to tracker", peer_trace);
		return;
	}
	printf("%s Connection to the tracker established.\n", peer_trace);

	ptp_peer_t pkt;
	p2T_pkt_set(&pkt, 0, NULL, REGISTER, NULL, myIP, PEER_PORT, 0, NULL);

	if (sendpkt(tracker_conn, &pkt) < 0) {
		printf("%s REGISTER sending failed!\n", peer_trace);
		peer_stop();
		return;
	}

	// create the alive thread
	pthread_t alive_thread;
	pthread_create(&alive_thread, NULL, Alive, NULL);
	printf("%s Alive thread created.\n", peer_trace);

	// create a P2P Listen thread
	pthread_t p2p_listen_thread;
	pthread_create(&p2p_listen_thread, NULL, P2PListen, NULL);
	printf("%s p2p listen thread created.\n", peer_trace);
	
	// create a file monitor thread
	char dir_name[FILE_NAME_LEN];
	printf("%s Please input the directory which you would like to monitor:", peer_trace);
	scanf("%s", dir_name);

	// create a loval file directory to monitor
	mkdir(dir_name, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
	chdir(dir_name);
	
	DIR *dir = opendir(".");
	if (dir == NULL) {
		printf("%s The directory which you input is invalid.\n", peer_trace);
		peer_stop();
		return;
	}
        struct dirent *entry;
	pthread_mutex_lock(peer_file_table_mutex);
	while ((entry = readdir(dir)) != NULL) {
		if (strcmp(".", entry->d_name) == 0 || strcmp("..", entry->d_name) == 0) {
			continue;
		}
		filenode tmp;
		memset(&tmp, 0, sizeof(filenode));
		strcpy(tmp.filename, entry->d_name);
		tmp.filesize = getFileSize(tmp.filename);
		if (tmp.filesize < 0) {
			continue;
		}
		tmp.timestamp = 0;
		strcpy(tmp.peerIP, myIP);
		fileTable_Add(&tmp, myIP);
	}
	pthread_mutex_unlock(peer_file_table_mutex);
	
	pthread_t file_monitor_thread;
	pthread_create(&file_monitor_thread, NULL, FileMonitor, (void *) ".");
	printf("%s file monitor thread created.\n", peer_trace);
	

//	int setup = 0;


	filenode *global_table;
	for (;;) {
		if (fileTable_Receive(tracker_conn, &global_table) < 0) {
			printf("%s Connection to the tracker is lost. Exiting...\n", peer_trace);
			break;
		}
		printf("%s Received a file table from the tracker:\n", peer_trace);
		fileTable_Print(global_table);
		pthread_mutex_lock(peer_file_table_mutex);

		// based on the global file table, update the local file table
		filenode *cur = global_table;
		while (cur != NULL) {
			if (cur != fileTable_Exist(global_table, cur->filename, NULL)) {
				// this file has been processed before
				cur = cur->next;
				continue;
			}

			filenode *tmp = fileTable_Exist(file_table, cur->filename, NULL);

			if (tmp == NULL) {
				// if our local file table doesn't have this file, should we add it?
				if (fileTable_Exist(global_table, cur->filename, myIP) != NULL) {
					// if this ip used to have the file in the global table, that means we just deleted locally, but the tracker hasn't updated it yet
					// thus we should not add this file, cause the delete action is the latest one
					cur = cur->next;
					continue;
				}
				else {
					// if this ip never has this file, we should add it
					fileTable_Add(cur, "");
					Download(cur->filename, cur->filesize, global_table);
				}
			}

			// if out local file table has this file, should we update it?
			else {
				// if this file is newly created but hasn't been marked with a timestamp from the tracker
				if (tmp->timestamp == 0) {
//					filenode *p = fileTable_Exist(global_table, cur->filename, myIP);
//					if (p != NULL && p->timestamp == fileTable_latest(global_table, cur->filename)) {
//						// update the timestamp given from the tracker
						tmp->timestamp = cur->timestamp;
//					}
//					else {
//						// some peer created this new file with the same name first or updated it first
//						// then we shuold change our name
//						strcat(strcat(tmp->name, " from "), myIP);
//					}
				}
				else {
					if (difftime(tmp->timestamp, cur->timestamp) >= 0) {
						// this file is the latest one, do nothing
						cur = cur->next;
						continue;
					}
					else {
						// not the latest one
						// need to update
						//remove(cur->filename);
						//fileTable_Add(cur, myIP);
						tmp->filesize = cur->filesize;
						tmp->timestamp = cur->timestamp;
						memset(tmp->peerIP, 0, IP_LEN);
						Download(cur->filename, cur->filesize, global_table);
					}
				}
			}
			cur = cur->next;
		}

//		if (setup > 0) {
//		//traverse the local file table to see if there's anything need to be deleted
			cur = file_table;
			while (cur != NULL) {
				if (fileTable_Exist(global_table, cur->filename, NULL) == NULL/* && cur->timestamp != 0*/) {
					// the global table doesn't have this file and the timestamp used to be assigned by the tracker
					remove(cur->filename);
					fileTable_Delete(cur->filename, myIP);
					// what if we can't delete this file
				}
				cur = cur->next;
			}
//		}
//		setup++;
		
		printf("%s Updated local file table:\n", peer_trace);
		fileTable_Print(file_table);
		fileTable_Destroy(global_table);
		pthread_mutex_unlock(peer_file_table_mutex);
	}

	peer_stop();
}
Exemple #21
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
    socklen_t clilen;
    int listenfd;
    //char buf[MAXLINE];
    struct sockaddr_in cliaddr,servaddr;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    memset(&servaddr, 0, sizeof(struct sockaddr_in));
    servaddr.sin_family=AF_INET;
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servaddr.sin_port=htons(SON_PORT);
    bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
    listen(listenfd,MAX_NODE_NUM);//开始监听
    clilen = sizeof(cliaddr);
    int connfd = accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
    sip_conn = connfd;
    printf("IP linked\n");
    while(1)
    {
        sip_pkt_t* pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
        memset(pkt,0,sizeof(sip_pkt_t));
        int nextNode = 0;
    // 如果成功接收sendpkt_arg_t结构, 返回1, 否则返回-1.
        if(getpktToSend(pkt,&nextNode,sip_conn)==1)
        {
            printf("in son ready to send:%d\n",pkt->header.src_nodeID);
            if(nextNode == BROADCAST_NODEID)
            {
                int i = 0;
                for(i = 0 ;i <topology_getNbrNum();i++)
                {
                    printf("send to everyone!\n");
                    if(nt[i].conn == -1)
                    {
                        printf("%d sleep no more send to him\n",nt[i].nodeID);
                        continue;
                    }
                    if(sendpkt(pkt, nt[i].conn) == 1)
                    {
                        printf("send to nextnode sucess! %d\n",nt[i].conn);
                    }
                    else
                    {
                        printf("send fail %d",i);
                    }
                }
            
            }
            else
            {
                int i = 0;
            for(i = 0 ;i <topology_getNbrNum();i++)
            {
                if(nextNode == nt[i].nodeID)
                {
                    break;
                }
            }
            if(i == topology_getNbrNum())
            {
                printf("cant find next node!\n");
                exit(0);
                
            }
            if(nt[i].conn == -1)
            {
                printf("%d sleep no more send to him\n",nt[i].nodeID);
                continue;
            }
            // 如果报文发送成功, 返回1, 否则返回-1.
            if(sendpkt(pkt, nt[i].conn) == 1)
            {
                printf("send to nextnode sucess!\n");
            }
            else
            {
                printf("send to nextnode fail\n");
            }
            }
        }
        else
        {
            printf("SIP stop!!!!!!!!!!!!!!!\n");
            break;
        }
   
        
    }
}
Exemple #22
0
static event_t *
get_packet_v(rtmp_t *r, uint8_t *data, size_t size, int64_t dts,
	     media_pipe_t *mp)
{
  uint8_t flags;
  uint8_t type = 0;
  enum CodecID id;
  int d = 0;
  event_t *e;

  if(r->r->m_read.flags & RTMP_READ_SEEKING)
    return NULL; 

  if(size < 2)
    return NULL;

  flags = *data++;
  size--;


  switch(flags & 0xf) {
  case 7:
    type = *data++;
    size--;
    id = CODEC_ID_H264;

    if(size < 3)
      return NULL;
    
    d = (AMF_DecodeInt24((char *)data) + 0xff800000) ^ 0xff800000;
    data += 3;
    size -= 3;
    break;

  case 4:
    type = *data++;
    size--;
    id = CODEC_ID_VP6F;
    break;
  default:
    return NULL;
  }

  if(r->vcodec == NULL) {
    AVCodecContext *ctx;
    media_codec_params_t mcp = {0};

    switch(id) {
    case CODEC_ID_H264:
      if(type != 0 || size < 0)
	return NULL;
	
      ctx = avcodec_alloc_context3(NULL);
      ctx->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
      memcpy(ctx->extradata, data, size);
      ctx->extradata_size =  size;
      break;

    case CODEC_ID_VP6F:
      if(size < 1)
	return NULL;

      ctx = avcodec_alloc_context3(NULL);
      ctx->extradata = av_mallocz(1 + FF_INPUT_BUFFER_PADDING_SIZE);
      memcpy(ctx->extradata, &type, 1);
      ctx->extradata_size =  1;
      break;

    default:
      abort();
    }
    mcp.width = r->width;
    mcp.height = r->height;
    r->vcodec = media_codec_create(id, 0, NULL, ctx, &mcp, mp);
    return NULL;
  }


  int skip = 0;

  int64_t pts = 1000LL * (dts + d);
  dts = 1000LL * dts;

  if(d < 0 || dts < r->seekpos) {
    skip = 1;
    r->in_seek_skip = 1;
  } else if(r->in_seek_skip) {
    skip = 2;
    r->in_seek_skip = 0;
  }

  r->lastdts = dts;

  e = sendpkt(r, &r->mp->mp_video, r->vcodec, dts, pts, AV_NOPTS_VALUE,
	      data, size, skip, MB_VIDEO, r->vframeduration);
  return e;
}
Exemple #23
0
static DECLARE_THREAD_FUNCTION(NetThread, param) {
	SOCKET_TYPE			listenfd, fdmax, i, clientfd;
	socklen_t			len;
	int					leni;
	fd_set				master, read_fds;
    struct sockaddr_in	addr;
    GDisplay *			g;
    netPriv *			priv;
	(void)param;

	// Start the sockets layer
	StartSockets();
	gfxSleepMilliseconds(100);					// Make sure the thread has time to start.

	/* clear the master and temp sets */
	FD_ZERO(&master);
	FD_ZERO(&read_fds);

	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == (SOCKET_TYPE)-1)
		gfxHalt("GDISP: uGFXnet - Socket failed");

	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	addr.sin_port = htons(GDISP_GFXNET_PORT);

	if (bind(listenfd, (struct sockaddr*)&addr, sizeof(addr)) == -1)
		gfxHalt("GDISP: uGFXnet - Bind failed");

    if (listen(listenfd, 10) == -1)
		gfxHalt("GDISP: uGFXnet - Listen failed");


    /* add the listener to the master set */
    FD_SET(listenfd, &master);

    /* keep track of the biggest file descriptor */
    fdmax = listenfd; /* so far, it's this one*/

	#if GDISP_GFXNET_BROKEN_LWIP_ACCEPT
    {
		#warning "Using GDISP_GFXNET_BROKEN_LWIP_ACCEPT limits the number of displays and the use of GFXNET. Avoid if possible!"
		len = sizeof(addr);
		if((clientfd = accept(listenfd, (struct sockaddr *)&addr, &len)) == (SOCKET_TYPE)-1)
			gfxHalt("GDISP: uGFXnet - Accept failed");

		// Look for a display that isn't connected
		for(g = 0; (g = (GDisplay *)gdriverGetNext(GDRIVER_TYPE_DISPLAY, (GDriver *)g));) {
            // Ignore displays for other controllers
            #ifdef GDISP_DRIVER_LIST
                if (gvmt(g) != &GDISPVMT_uGFXnet)
                    continue;
            #endif
			if (!(g->flags & GDISP_FLG_CONNECTED))
				break;
		}

		// Was anything found?
		if (!g) {
			// No Just close the connection
			closesocket(clientfd);
			gfxHalt("GDISP: uGFXnet - Can't find display for connection");
			return 0;
		}

		// Save the descriptor
		FD_SET(clientfd, &master);
		if (clientfd > fdmax) fdmax = clientfd;
		priv = g->priv;
		memset(priv, 0, sizeof(netPriv));
		priv->netfd = clientfd;
		//printf(New connection from %s on socket %d allocated to display %u\n", inet_ntoa(addr.sin_addr), clientfd, disp+1);

		// Send the initialisation data (2 words at a time)
		priv->data[0] = GNETCODE_INIT;
		priv->data[1] = GNETCODE_VERSION;
		sendpkt(priv->netfd, priv->data, 2);
		priv->data[0] = GDISP_SCREEN_WIDTH;
		priv->data[1] = GDISP_SCREEN_HEIGHT;
		sendpkt(priv->netfd, priv->data, 2);
		priv->data[0] = GDISP_LLD_PIXELFORMAT;
		priv->data[1] = (g->flags & GDISP_FLG_HASMOUSE) ? 1 : 0;
		MUTEX_ENTER;
		sendpkt(priv->netfd, priv->data, 2);
		MUTEX_EXIT;

		// The display is now working
		g->flags |= GDISP_FLG_CONNECTED;

		// Send a redraw all
		#if GFX_USE_GWIN && GWIN_NEED_WINDOWMANAGER
			gdispGClear(g, gwinGetDefaultBgColor());
			gwinRedrawDisplay(g, FALSE);
		#endif
    }
	#endif

    /* loop */
    for(;;) {
		/* copy it */
		read_fds = master;
		if (select(fdmax+1, &read_fds, 0, 0, 0) == -1)
			gfxHalt("GDISP: uGFXnet - Select failed");

		// Run through the existing connections looking for data to be read
		for(i = 0; i <= fdmax; i++) {
			if(!FD_ISSET(i, &read_fds))
				continue;

			// Handle new connections
			if(i == listenfd) {
				len = sizeof(addr);
				if((clientfd = accept(listenfd, (struct sockaddr *)&addr, &len)) == (SOCKET_TYPE)-1)
					gfxHalt("GDISP: uGFXnet - Accept failed");

                // Look for a display that isn't connected
                for(g = 0; (g = (GDisplay *)gdriverGetNext(GDRIVER_TYPE_DISPLAY, (GDriver *)g));) {
                    // Ignore displays for other controllers
                    #ifdef GDISP_DRIVER_LIST
                        if (gvmt(g) != &GDISPVMT_uGFXnet)
                            continue;
                    #endif
                    if (!(g->flags & GDISP_FLG_CONNECTED))
                        break;
                }

				// Was anything found?
				if (!g) {
					// No Just close the connection
					closesocket(clientfd);
					//printf(New connection from %s on socket %d rejected as all displays are already connected\n", inet_ntoa(addr.sin_addr), clientfd);
					continue;
				}

				// Save the descriptor
				FD_SET(clientfd, &master);
				if (clientfd > fdmax) fdmax = clientfd;
				priv = g->priv;
				memset(priv, 0, sizeof(netPriv));
				priv->netfd = clientfd;
				//printf(New connection from %s on socket %d allocated to display %u\n", inet_ntoa(addr.sin_addr), clientfd, disp+1);

				// Send the initialisation data (2 words at a time)
				priv->data[0] = GNETCODE_INIT;
				priv->data[1] = GNETCODE_VERSION;
				sendpkt(priv->netfd, priv->data, 2);
				priv->data[0] = GDISP_SCREEN_WIDTH;
				priv->data[1] = GDISP_SCREEN_HEIGHT;
				sendpkt(priv->netfd, priv->data, 2);
				priv->data[0] = GDISP_LLD_PIXELFORMAT;
				priv->data[1] = (g->flags & GDISP_FLG_HASMOUSE) ? 1 : 0;
				MUTEX_ENTER;
				sendpkt(priv->netfd, priv->data, 2);
				MUTEX_EXIT;

				// The display is now working
				g->flags |= GDISP_FLG_CONNECTED;

				// Send a redraw all
				#if GFX_USE_GWIN && GWIN_NEED_WINDOWMANAGER
					gdispGClear(g, gwinGetDefaultBgColor());
					gwinRedrawDisplay(g, FALSE);
				#endif

				continue;
			}

			// Handle data from a client

			// Look for a display that is connected and the socket descriptor matches
            for(g = 0; (g = (GDisplay *)gdriverGetNext(GDRIVER_TYPE_DISPLAY, (GDriver *)g));) {
                // Ignore displays for other controllers
                #ifdef GDISP_DRIVER_LIST
                    if (gvmt(g) != &GDISPVMT_uGFXnet)
                        continue;
                #endif
				priv = g->priv;
				if ((g->flags & GDISP_FLG_CONNECTED) && priv->netfd == i)
					break;
            }
			if (!g)
				gfxHalt("GDISP: uGFXnet - Got data from unrecognized connection");

			if ((g->flags & GDISP_FLG_HAVEDATA)) {
				// The higher level is still processing the previous data.
				//	Give it a chance to run by coming back to this data.
				gfxSleepMilliseconds(1);
				continue;
			}

			/* handle data from a client */
			MUTEX_ENTER;
			if ((leni = recv(i, ((char *)priv->data)+priv->databytes, sizeof(priv->data)-priv->databytes, 0)) <= 0) {
				// Socket closed or in error state
				MUTEX_EXIT;
				g->flags &= ~GDISP_FLG_CONNECTED;
				memset(priv, 0, sizeof(netPriv));
				closesocket(i);
				FD_CLR(i, &master);
				continue;
			}
			MUTEX_EXIT;

			// Do we have a full reply yet
			priv->databytes += leni;
			if (priv->databytes < sizeof(priv->data))
				continue;
			priv->databytes = 0;

			// Convert network byte or to host byte order
			priv->data[0] = ntohs(priv->data[0]);
			priv->data[1] = ntohs(priv->data[1]);

			// Process the data received
			switch(priv->data[0]) {
			#if GINPUT_NEED_MOUSE
				case GNETCODE_MOUSE_X:		priv->mousex = priv->data[1];		break;
				case GNETCODE_MOUSE_Y:		priv->mousey = priv->data[1];		break;
				case GNETCODE_MOUSE_B:
					priv->mousebuttons = priv->data[1];
					// Treat the button event as the sync signal
					#if GINPUT_MOUSE_POLL_PERIOD == TIME_INFINITE
						ginputMouseWakeup();
					#endif
					break;
			#endif
			case GNETCODE_CONTROL:
			case GNETCODE_READ:
				g->flags |= GDISP_FLG_HAVEDATA;
				break;
			case GNETCODE_KILL:
				gfxHalt("GDISP: uGFXnet - Display sent KILL command");
				break;

			default:
				// Just ignore unrecognised data
				break;
			}
		}
	}
    return 0;
}
Exemple #24
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	//你需要编写这里的代码.
	int nbrNum = topology_getNbrNum();
	int listenfd=0;
	struct sockaddr_in servaddr,cliaddr;
	socklen_t clilen;
	if ((listenfd=socket(AF_INET, SOCK_STREAM,0))<0) 
	{
		puts("create socket error!");
	}
	servaddr.sin_family=AF_INET;
	servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
	servaddr.sin_port=htons(SON_PORT);
	const int on = 1;
	setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
	bind(listenfd,(struct sockaddr *)&servaddr, sizeof(servaddr));
	puts("SON Wait For SIP Server Init Success!");	
	listen(listenfd,1);
	while(1){
	sip_conn=accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
	puts("Accept SIP Process!");
	int nextNode=0;
	sip_pkt_t* recv_seg=malloc(sizeof(sip_pkt_t));
	memset(recv_seg,0,sizeof(sip_pkt_t));
	while (1){
		if (getpktToSend(recv_seg,&nextNode,sip_conn)!=1)
			//continue;
			break;
		if (nextNode==BROADCAST_NODEID){
			//char *flags=malloc(nbrNum);
			//memset(flags,0,nbrNum);
			for (int i=0;i<nbrNum;i++)
			{
				if (sendpkt(recv_seg,nt[i].conn)==-1) {
					//flags[i]=1;
				}
			}/*
			for (int i=0;i<nbrNum;i++) {
				if (flags[i]==1) {
					forwardpktToSIP(build_failpkt(nt[i].nodeID),sip_conn);
				}
			}
			free(flags);*/
		}
		else{
			for (int i=0;i<nbrNum;i++)
			{
				if (nt[i].nodeID==nextNode)
				{
					if (sendpkt(recv_seg,nt[i].conn)==-1) {
						//forwardpktToSIP(build_failpkt(nt[i].nodeID),sip_conn);
					}
					break;
				}
			}
		}
	}
	printf("####SIP stop!! listening for next SIP\n");
	close(sip_conn);
	}
}
Exemple #25
0
static event_t *
get_packet_a(rtmp_t *r, uint8_t *data, size_t size, int64_t dts, 
	     media_pipe_t *mp)
{
  uint8_t flags;
  uint8_t type = 0;
  enum CodecID id;

  if(r->r->m_read.flags & RTMP_READ_SEEKING)
    return NULL; 

  if(size < 2)
    return NULL;

  flags = *data++;
  size--;

  switch(flags & 0xf0) {
  case 0xa0:   id = CODEC_ID_AAC;
    type = *data++;
    size--;
    break;

  case 0x20:
    id = CODEC_ID_MP3;
    break;

  default: 
    return NULL;
  }
    
  if(r->acodec == NULL) {
    AVCodecContext *ctx;
    int parse = 0;
    const char *fmt;

    switch(id) {
      
    case CODEC_ID_AAC:
      if(type != 0 || size < 0)
	return NULL;
	
      ctx = avcodec_alloc_context3(NULL);
      ctx->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
      memcpy(ctx->extradata, data, size);
      ctx->extradata_size =  size;
      fmt = "AAC";
      break;

    case CODEC_ID_MP3:
      ctx = avcodec_alloc_context3(NULL);
      parse = 1;
      fmt = "MP3";
      break;

    default:
      abort();
    }

    mp_add_track(mp->mp_prop_audio_tracks,
		 NULL,
		 "rtmp:1",
		 fmt,
		 fmt,
		 NULL, 
		 NULL,
		 NULL,
		 0);

    prop_set_string(mp->mp_prop_audio_track_current, "rtmp:1");

    r->acodec = media_codec_create(id, parse, NULL, ctx, NULL, mp);
    return NULL;
  }

  media_codec_t *mc = r->acodec;

  dts *= 1000;

  if(dts < r->seekpos)
    return NULL;


  if(mc->parser_ctx == NULL)
    return sendpkt(r, &mp->mp_audio, mc, 
		   dts, dts, dts, data, size, 0, MB_AUDIO, 0);

  while(size > 0) {
    int outlen;
    uint8_t *outbuf;
    int rlen = av_parser_parse2(mc->parser_ctx,
				mc->codec_ctx, &outbuf, &outlen, 
				data, size, dts, dts, AV_NOPTS_VALUE);
    if(outlen) {
      event_t *e = sendpkt(r, &mp->mp_audio, mc,
			   mc->parser_ctx->dts,
			   mc->parser_ctx->pts, mc->parser_ctx->dts,
			   outbuf, outlen, 0,
			   MB_AUDIO, 0);
      if(e != NULL)
	return e;
    }
    dts = AV_NOPTS_VALUE;
    data += rlen;
    size -= rlen;
  }
  return NULL;
}
Exemple #26
0
static event_t *
get_packet_a(rtmp_t *r, uint8_t *data, int size, int64_t dts, 
	     media_pipe_t *mp)
{
  uint8_t flags;
  uint8_t type = 0;
  enum AVCodecID id;

  if(r->r->m_read.flags & RTMP_READ_SEEKING)
    return NULL; 

  if(size < 2)
    return NULL;

  flags = *data++;
  size--;

  switch(flags & 0xf0) {
  case 0xa0:   id = AV_CODEC_ID_AAC;
    type = *data++;
    size--;
    break;

  case 0x20:
    id = AV_CODEC_ID_MP3;
    break;

  default: 
    return NULL;
  }
    
  if(r->acodec == NULL) {
    media_codec_params_t mcp = {0};
    int parse = 0;
    const char *fmt;

    switch(id) {
      
    case AV_CODEC_ID_AAC:
      if(type != 0 || size < 0)
	return NULL;
	
      mcp.extradata      = data;
      mcp.extradata_size = size;
      fmt = "AAC";
      break;

    case AV_CODEC_ID_MP3:
      parse = 1;
      fmt = "MP3";
      break;

    default:
      abort();
    }

    mp_add_track(mp->mp_prop_audio_tracks,
		 NULL,
		 "rtmp:1",
		 fmt,
		 fmt,
		 NULL, 
		 NULL,
		 NULL,
		 0,
                 1);

    prop_set_string(mp->mp_prop_audio_track_current, "rtmp:1");

    r->acodec = media_codec_create(id, parse, NULL, NULL, &mcp, mp);
    return NULL;
  }

  media_codec_t *mc = r->acodec;

  dts *= 1000;

  if(dts <= r->seekpos_audio)
    return NULL;

  r->seekpos_audio = dts;
  if(mc->parser_ctx == NULL)
    return sendpkt(r, &mp->mp_audio, mc, 
		   dts, dts, data, size, 0, MB_AUDIO, 0, 0);

  while(size > 0) {
    int outlen;
    uint8_t *outbuf;
    int rlen = av_parser_parse2(mc->parser_ctx,
				mc->fmt_ctx, &outbuf, &outlen, 
				data, size, dts, dts, AV_NOPTS_VALUE);
    if(outlen) {
      event_t *e = sendpkt(r, &mp->mp_audio, mc,
			   mc->parser_ctx->dts,
			   mc->parser_ctx->pts,
			   outbuf, outlen, 0,
			   MB_AUDIO, 0, 0);
      if(e != NULL)
	return e;
    }
    dts = AV_NOPTS_VALUE;
    data += rlen;
    size -= rlen;
  }
  return NULL;
}
Exemple #27
0
//这个函数打开TCP端口SON_PORT, 等待来自本地SIP进程的进入连接. 
//在本地SIP进程连接之后, 这个函数持续接收来自SIP进程的sendpkt_arg_t结构, 并将报文发送到重叠网络中的下一跳. 
//如果下一跳的节点ID为BROADCAST_NODEID, 报文应发送到所有邻居节点.
void waitSIP() {
	int sockfd;
	struct sockaddr_in cli_addr, serv_addr;
	socklen_t clilen;
	if((sockfd = socket(AF_INET, SOCK_STREAM, 0))<0) {
		perror("Error create socket\n");
		exit(-1);
	}
	const int one = 1;	//port可以立即重新使用
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
	
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(SON_PORT);
	if(bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))<0) {
		perror("Error bind\n");
		exit(-1);
	}
	listen(sockfd, MAX_NODE_NUM);
	clilen = sizeof(cli_addr);
	while(1) {
		sip_conn = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);
		sip_pkt_t* sip_pkt;
		int next;
		while(1) {
			sip_pkt = (sip_pkt_t*)malloc(sizeof(sip_pkt_t));
			memset(sip_pkt, 0, sizeof(sip_pkt_t));
			if(getpktToSend(sip_pkt, &next, sip_conn)>0) {
				if(next == BROADCAST_NODEID) {
					int nbrnum = topology_getNbrNum();
					int i = 0;
					for(i=0; i<nbrnum; i++) {
						//if(nt[i].conn > 0) {
							sendpkt(sip_pkt, nt[i].conn);
						//}
						//else {
							//printf("sendpkt conn<0, id: %d\n", nt[i].nodeID);
						//}
					}
				}
				else {
					if(sip_pkt->header.type == SIP) {
						printf("Receive stcp packet!\n");
					}
					int nbrnum = topology_getNbrNum();
					int i = 0;
					for(i=0; i<nbrnum; i++) {
						if(next == nt[i].nodeID) {
							printf("send message to node %d\n", next);
							sendpkt(sip_pkt, nt[i].conn);
							break;
						}
					}
				}
			}
			else {
				free(sip_pkt);
				close(sip_conn);
				break;
			}
			free(sip_pkt);
		}
	}
	return;
}
Exemple #28
0
	LLDSPEC void gdisp_lld_control(GDisplay *g) {
		netPriv	*	priv;
		uint16_t	buf[3];
		bool_t		allgood;

		#if GDISP_DONT_WAIT_FOR_NET_DISPLAY
			if (!(g->flags & GDISP_FLG_CONNECTED))
				return;
		#else
			while(!(g->flags & GDISP_FLG_CONNECTED))
				gfxSleepMilliseconds(200);
		#endif

		// Check if we might support the code
		switch(g->p.x) {
		case GDISP_CONTROL_ORIENTATION:
			if (g->g.Orientation == (orientation_t)g->p.ptr)
				return;
			break;
		case GDISP_CONTROL_POWER:
			if (g->g.Powermode == (powermode_t)g->p.ptr)
				return;
			break;
		case GDISP_CONTROL_BACKLIGHT:
			if (g->g.Backlight == (uint16_t)(int)g->p.ptr)
				return;
			if ((uint16_t)(int)g->p.ptr > 100)
				g->p.ptr = (void *)100;
			break;
		default:
			return;
		}

		// Send the command
		priv = g->priv;
		buf[0] = GNETCODE_CONTROL;
		buf[1] = g->p.x;
		buf[2] = (uint16_t)(int)g->p.ptr;
		MUTEX_ENTER;
		sendpkt(priv->netfd, buf, 3);
		MUTEX_EXIT;

		// Now wait for a reply
		while(!(g->flags & GDISP_FLG_HAVEDATA) || priv->data[0] != GNETCODE_CONTROL)
			gfxSleepMilliseconds(1);

		// Extract the return status
		allgood = priv->data[1] ? TRUE : FALSE;
		g->flags &= ~GDISP_FLG_HAVEDATA;

		// Do nothing more if the operation failed
		if (!allgood) return;

		// Update the local stuff
		switch(g->p.x) {
		case GDISP_CONTROL_ORIENTATION:
			switch((orientation_t)g->p.ptr) {
				case GDISP_ROTATE_0:
				case GDISP_ROTATE_180:
					g->g.Width = GDISP_SCREEN_WIDTH;
					g->g.Height = GDISP_SCREEN_HEIGHT;
					break;
				case GDISP_ROTATE_90:
				case GDISP_ROTATE_270:
					g->g.Height = GDISP_SCREEN_WIDTH;
					g->g.Width = GDISP_SCREEN_HEIGHT;
					break;
				default:
					return;
			}
			g->g.Orientation = (orientation_t)g->p.ptr;
			break;
		case GDISP_CONTROL_POWER:
			g->g.Powermode = (powermode_t)g->p.ptr;
			break;
		case GDISP_CONTROL_BACKLIGHT:
			g->g.Backlight = (uint16_t)(int)g->p.ptr;
			break;
		}
	}
Exemple #29
0
/**
 * Our main function.
 * There are two prototypes - one for systems with a command line and one for embedded systems without one.
 */
int main(proto_args) {
	uint16_t			cmd[5];
	unsigned			cnt;


	// Initialize and clear the display
	gfxInit();
	font = gdispOpenFont("UI2");

	// Open the connection
	gdispDrawStringBox(0, 0, gdispGetWidth(), gdispGetHeight(), "Connecting to host...", font, White, justifyCenter);
	StartSockets();
	netfd = doConnect(cmd_args);
	if (netfd == (SOCKET_TYPE)-1)
		gfxHalt("Could not connect to the specified server");
	gdispClear(Black);

	// Get the initial packet from the host
	if (!getpkt(cmd, 2)) goto alldone;
	if (cmd[0] != GNETCODE_INIT || cmd[1] != GNETCODE_VERSION)
		gfxHalt("Oops - The protocol doesn't look like one we understand");

	// Get the rest of the initial arguments
	if (!getpkt(cmd, 4)) goto alldone;						// cmd[] = width, height, pixelformat, hasmouse

	// We will ignore size mismatches but the pixel format must match
	if (cmd[2] != GDISP_PIXELFORMAT)
		gfxHalt("Oops - The remote display is using a different pixel format to us.\nTry defining GDISP_PIXELFORMAT in your gfxconf.h file.");

	#if GFX_USE_GINPUT && GINPUT_NEED_MOUSE
		// Start the mouse thread if needed
		if (cmd[3])
			gfxThreadClose(gfxThreadCreate(waNetThread, sizeof(waNetThread), HIGH_PRIORITY, NetThread, 0));
	#endif

	// Process incoming instructions
	while(getpkt(cmd, 1)) {
		switch(cmd[0]) {
		case GNETCODE_FLUSH:
			gdispFlush();
			break;
		case GNETCODE_PIXEL:
			if (!getpkt(cmd, 3)) goto alldone;				// cmd[] = x, y, color
			gdispDrawPixel(cmd[0], cmd[1], cmd[2]);
			break;
		case GNETCODE_FILL:
			if (!getpkt(cmd, 5)) goto alldone;				// cmd[] = x, y, cx, cy, color
			gdispFillArea(cmd[0], cmd[1], cmd[2], cmd[3], cmd[4]);
			break;
		case GNETCODE_BLIT:
			if (!getpkt(cmd, 4)) goto alldone;				// cmd[] = x, y, cx, cy		- Followed by cx * cy pixels
			gdispStreamStart(cmd[0],cmd[1],cmd[2],cmd[3]);
			for(cnt = (unsigned)cmd[2] * cmd[3]; cnt; cnt--) {
				if (!getpkt(cmd, 1)) goto alldone;
				gdispStreamColor(cmd[0]);
			}
			gdispStreamStop();
			break;
		#if GDISP_NEED_PIXELREAD
			case GNETCODE_READ:
				if (!getpkt(cmd, 2)) goto alldone;				// cmd[] = x, y				- Response is GNETCODE_READ,color
				cmd[1] = gdispGetPixelColor(cmd[0], cmd[1]);
				cmd[0] = GNETCODE_READ;
				if (!sendpkt(cmd, 2)) goto alldone;
				break;
		#endif
		#if GDISP_NEED_SCROLL
			case GNETCODE_SCROLL:
				if (!getpkt(cmd, 5)) goto alldone;				// cmd[] = x, y, cx, cy, lines
				gdispVerticalScroll(cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], Black);
				break;
		#endif
		case GNETCODE_CONTROL:
			if (!getpkt(cmd, 2)) goto alldone;				// cmd[] = what,data		- Response is GNETCODE_CONTROL, 0x0000 (fail) or GNETCODE_CONTROL, 0x0001 (success)
			gdispControl(cmd[0], (void *)(unsigned)cmd[1]);
			switch(cmd[0]) {
			case GDISP_CONTROL_ORIENTATION:
				cmd[1] = (uint16_t)gdispGetOrientation() == cmd[1] ? 1 : 0;
				break;
			case GDISP_CONTROL_POWER:
				cmd[1] = (uint16_t)gdispGetPowerMode() == cmd[1] ? 1 : 0;
				break;
			case GDISP_CONTROL_BACKLIGHT:
				cmd[1] = (uint16_t)gdispGetBacklight() == cmd[1] ? 1 : 0;
				break;
			default:
				cmd[1] = 0;
				break;
			}
			cmd[0] = GNETCODE_CONTROL;
			if (!sendpkt(cmd, 2)) goto alldone;
			break;
		default:
			gfxHalt("Oops - The host has sent invalid commands");
			break;
		}
	}

alldone:
	closesocket(netfd);
	gfxHalt("Connection closed");
	return 0;
}
Exemple #30
0
void pinghandler() {
    char pkt[15];
    sprintf(pkt, "#pingreply#:%d", cliid);
    sendpkt(gservaddr, pkt, SERVPORT);
}