[netwatch.git] / watcher / watcher.c

#include <pcap.h>
#include <ctype.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

char errbuf[PCAP_ERRBUF_SIZE];

char buf[0x8000];

typedef struct netwatch_frame {
	char dest_mac[6];
	char src_mac[6];
	unsigned short whatthefuck;
	unsigned short ethertype;
	unsigned short buf_offset;
	unsigned short buf_window;
	char data[];
} netwatch_frame;

pcap_t * pcap;

void out(char *buf, unsigned short start)
{
  int y,x;
  buf += start;
  printf("\x1B[H");
  for (y = 0; y < 25; y++)
  {
    printf("\x1B[%d;%df",y+1,1);
    for (x = 0; x < 80; x++)
    {
      unsigned char c, col;
      static unsigned char last = 0xFF;
      
      c = *(buf++);
      col = *(buf++);

      if (col != last)
      {
      printf("\x1B[0m\x1B[");
      switch (col & 0x7)
      {
      case 0: printf("30;"); break;
      case 1: printf("34;"); break;
      case 2: printf("32;"); break;
      case 3: printf("36;"); break;
      case 4: printf("31;"); break;
      case 5: printf("35;"); break;
      case 6: printf("33;"); break;
      case 7: printf("37;"); break;
      }
      if (col & 0x8)
        printf("m\x1B[1;");
      if (col & 0x80)
        printf("m\x1B[5;");
      switch ((col >> 4) & 0x7)
      {
      case 0: printf("40"); break;
      case 1: printf("44"); break;
      case 2: printf("42"); break;
      case 3: printf("46"); break;
      case 4: printf("41"); break;
      case 5: printf("45"); break;
      case 6: printf("43"); break;
      case 7: printf("47"); break;
      }
      printf("m");
      }
      last = col;
      if (c == 0)
      	c = ' ';
      printf("%c", c);
      fflush(stdout);
    }
  }
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>

typedef struct frame {
	char header[14];
	unsigned short datalen;
	unsigned char cmd;
	char data[];
} frame;

int sendsock;

void send_text(char *d, int len)
{
	int datalen = sizeof(frame) + len;
	frame * f = alloca(datalen + 1);
	struct sockaddr_ll addr;

	memcpy(f->header, "\x00\xb0\xd0\x97\xbc\xac\x00\x03\x93\x87\x84\x8C\x13\x38", 14);
	f->datalen = len;
	f->cmd = 0x42;
	memcpy(f->data, d, len);
	
	addr.sll_family = AF_PACKET;
	addr.sll_ifindex = 2;
	addr.sll_halen = 0;

 	if (sendto(sendsock, f, datalen, 0, (struct sockaddr *)&addr, sizeof(addr)) < datalen)
		perror("sendto");
}

void send_reboot() {
	frame f;
	struct sockaddr_ll addr;

	memcpy(f.header, "\x00\xb0\xd0\x97\xbc\xac\x00\x03\x93\x87\x84\x8C\x13\x38", 14);
	f.datalen = 0;
	f.cmd = 0xFE;
	addr.sll_family = AF_PACKET;
	addr.sll_ifindex = 2;
	addr.sll_halen = 0;

 	if (sendto(sendsock, &f, sizeof(frame), 0, (struct sockaddr *)&addr, sizeof(addr)) < sizeof(frame))
		perror("sendto");
}

void handler (u_char * user, const struct pcap_pkthdr *h, const u_char *bytes)
{
	netwatch_frame * f = (netwatch_frame *) bytes;
	static int i = 0;

	int data_len = h->caplen - sizeof(netwatch_frame) - 4;

	if (data_len < 0) return;

	if (ntohs(f->ethertype) != 0x1337) return;

	if (data_len > sizeof(buf)) return;

	if (f->buf_offset + data_len > sizeof(buf))
	{
		int wrap_pos = sizeof(buf) - f->buf_offset;
		memcpy(buf + f->buf_offset, f->data, wrap_pos);
		memcpy(buf, f->data + wrap_pos, data_len - wrap_pos);
	} else {
		memcpy(buf + f->buf_offset, f->data, data_len);
	}

	int c = getchar();
	if (c > 0) {
		if (c == 3)
			pcap_breakloop(pcap);
		if (c == '\r') c = '\n';
		if (c == 127) c = '\b';
		if (c == 0x1B)
		{
			/* Escape */
			c = getchar();
			if (c == '[')
			{
				c = getchar();
				if (c == 'A')
					c = 0x82;
				if (c == 'B')
					c = 0x83;
				if (c == 'D')
					c = 0x84;
				if (c == 'C')
					c = 0x85;
				if (c == '4')
					send_reboot();
			}
		}

		char ch = c;
		send_text(&ch, 1);
	}

	if (!(i++ % 2))
		out(buf, f->buf_window);
}

int main() {
	pcap = pcap_open_live(NULL, 65535, 1, 0, errbuf);
 
	if (!pcap)
	{
		printf("pcap_open_live: %s\n", errbuf);
		exit(1);
	}
	sendsock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
	if(sendsock < 0)
	{
		perror("socket");
		exit(1);
	}
	fcntl(0, F_SETFL, O_NONBLOCK);
	printf("\x1b[H\x1b[J\x1b[5C");

	struct termios t, t_orig;
	tcgetattr(0, &t);
	tcgetattr(0, &t_orig);
	cfmakeraw(&t);
	tcsetattr(0, 0, &t);

	pcap_loop(pcap, -1, handler, NULL);

	tcsetattr(0, 0, &t_orig);
	return 0;
}
Commit	Line	Data
172a5ba7	1	#include <pcap.h>
974b62de	2	#include <ctype.h>
	3	#include <termios.h>
	4	#include <unistd.h>
	5	#include <fcntl.h>
172a5ba7	6	#include <arpa/inet.h>
	7	#include <stdlib.h>
	8	#include <string.h>
	9
	10	char errbuf[PCAP_ERRBUF_SIZE];
	11
	12	char buf[0x8000];
	13
	14	typedef struct netwatch_frame {
	15	char dest_mac[6];
	16	char src_mac[6];
	17	unsigned short whatthefuck;
	18	unsigned short ethertype;
	19	unsigned short buf_offset;
	20	unsigned short buf_window;
	21	char data[];
	22	} netwatch_frame;
	23
974b62de	24	pcap_t * pcap;
974b62de	25
172a5ba7	26	void out(char *buf, unsigned short start)
	27	{
	28	int y,x;
	29	buf += start;
974b62de	30	printf("\x1B[H");
172a5ba7	31	for (y = 0; y < 25; y++)
172a5ba7	32	{
974b62de	33	printf("\x1B[%d;%df",y+1,1);
172a5ba7	34	for (x = 0; x < 80; x++)
	35	{
	36	unsigned char c, col;
974b62de	37	static unsigned char last = 0xFF;
172a5ba7	38
	39	c = *(buf++);
	40	col = *(buf++);
974b62de	41
	42	if (col != last)
	43	{
	44	printf("\x1B[0m\x1B[");
172a5ba7	45	switch (col & 0x7)
	46	{
	47	case 0: printf("30;"); break;
	48	case 1: printf("34;"); break;
	49	case 2: printf("32;"); break;
	50	case 3: printf("36;"); break;
	51	case 4: printf("31;"); break;
	52	case 5: printf("35;"); break;
	53	case 6: printf("33;"); break;
	54	case 7: printf("37;"); break;
	55	}
	56	if (col & 0x8)
974b62de	57	printf("m\x1B[1;");
172a5ba7	58	if (col & 0x80)
974b62de	59	printf("m\x1B[5;");
172a5ba7	60	switch ((col >> 4) & 0x7)
	61	{
	62	case 0: printf("40"); break;
	63	case 1: printf("44"); break;
	64	case 2: printf("42"); break;
	65	case 3: printf("46"); break;
	66	case 4: printf("41"); break;
	67	case 5: printf("45"); break;
	68	case 6: printf("43"); break;
	69	case 7: printf("47"); break;
	70	}
974b62de	71	printf("m");
	72	}
	73	last = col;
	74	if (c == 0)
	75	c = ' ';
974b62de	76	printf("%c", c);
974b62de	77	fflush(stdout);
172a5ba7	78	}
172a5ba7	79	}
	80	}
	81
974b62de	82
	83
	84
	85	#include <stdio.h>
	86	#include <stdlib.h>
	87	#include <string.h>
	88	#include <sys/types.h>
	89	#include <sys/socket.h>
	90	#include <netpacket/packet.h>
	91	#include <net/ethernet.h>
	92
	93	typedef struct frame {
	94	char header[14];
	95	unsigned short datalen;
	96	unsigned char cmd;
	97	char data[];
	98	} frame;
	99
	100	int sendsock;
	101
	102	void send_text(char *d, int len)
	103	{
	104	int datalen = sizeof(frame) + len;
	105	frame * f = alloca(datalen + 1);
	106	struct sockaddr_ll addr;
	107
	108	memcpy(f->header, "\x00\xb0\xd0\x97\xbc\xac\x00\x03\x93\x87\x84\x8C\x13\x38", 14);
	109	f->datalen = len;
	110	f->cmd = 0x42;
	111	memcpy(f->data, d, len);
	112
	113	addr.sll_family = AF_PACKET;
	114	addr.sll_ifindex = 2;
	115	addr.sll_halen = 0;
	116
	117	if (sendto(sendsock, f, datalen, 0, (struct sockaddr *)&addr, sizeof(addr)) < datalen)
	118	perror("sendto");
	119	}
	120
35592f46	121	void send_reboot() {
	122	frame f;
	123	struct sockaddr_ll addr;
	124
	125	memcpy(f.header, "\x00\xb0\xd0\x97\xbc\xac\x00\x03\x93\x87\x84\x8C\x13\x38", 14);
	126	f.datalen = 0;
	127	f.cmd = 0xFE;
	128	addr.sll_family = AF_PACKET;
	129	addr.sll_ifindex = 2;
	130	addr.sll_halen = 0;
	131
	132	if (sendto(sendsock, &f, sizeof(frame), 0, (struct sockaddr *)&addr, sizeof(addr)) < sizeof(frame))
	133	perror("sendto");
	134	}
	135
172a5ba7	136	void handler (u_char * user, const struct pcap_pkthdr h, const u_char bytes)
	137	{
	138	netwatch_frame * f = (netwatch_frame *) bytes;
974b62de	139	static int i = 0;
172a5ba7	140
974b62de	141	int data_len = h->caplen - sizeof(netwatch_frame) - 4;
172a5ba7	142
	143	if (data_len < 0) return;
	144
	145	if (ntohs(f->ethertype) != 0x1337) return;
	146
	147	if (data_len > sizeof(buf)) return;
	148
	149	if (f->buf_offset + data_len > sizeof(buf))
	150	{
	151	int wrap_pos = sizeof(buf) - f->buf_offset;
	152	memcpy(buf + f->buf_offset, f->data, wrap_pos);
	153	memcpy(buf, f->data + wrap_pos, data_len - wrap_pos);
	154	} else {
	155	memcpy(buf + f->buf_offset, f->data, data_len);
	156	}
	157
974b62de	158	int c = getchar();
	159	if (c > 0) {
	160	if (c == 3)
	161	pcap_breakloop(pcap);
	162	if (c == '\r') c = '\n';
	163	if (c == 127) c = '\b';
35592f46	164	if (c == 0x1B)
	165	{
	166	/* Escape */
	167	c = getchar();
	168	if (c == '[')
	169	{
	170	c = getchar();
	171	if (c == 'A')
	172	c = 0x82;
	173	if (c == 'B')
	174	c = 0x83;
	175	if (c == 'D')
	176	c = 0x84;
	177	if (c == 'C')
	178	c = 0x85;
	179	if (c == '4')
	180	send_reboot();
	181	}
	182	}
974b62de	183
	184	char ch = c;
	185	send_text(&ch, 1);
	186	}
	187
	188	if (!(i++ % 2))
	189	out(buf, f->buf_window);
172a5ba7	190	}
	191
	192	int main() {
172a5ba7	193	pcap = pcap_open_live(NULL, 65535, 1, 0, errbuf);
	194
	195	if (!pcap)
	196	{
	197	printf("pcap_open_live: %s\n", errbuf);
	198	exit(1);
	199	}
974b62de	200	sendsock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
	201	if(sendsock < 0)
	202	{
	203	perror("socket");
	204	exit(1);
	205	}
	206	fcntl(0, F_SETFL, O_NONBLOCK);
	207	printf("\x1b[H\x1b[J\x1b[5C");
	208
	209	struct termios t, t_orig;
	210	tcgetattr(0, &t);
	211	tcgetattr(0, &t_orig);
	212	cfmakeraw(&t);
	213	tcsetattr(0, 0, &t);
172a5ba7	214
	215	pcap_loop(pcap, -1, handler, NULL);
	216
974b62de	217	tcsetattr(0, 0, &t_orig);
172a5ba7	218	return 0;
172a5ba7	219	}