int TCP_RECEIVEOBJ::start_watching(void)
{
if (sock)
{
clear_buffer();
sprintf(writebuf,"watch %d\n",streamnum);
if (SDLNet_TCP_Send(sock, writebuf, strlen(writebuf))==strlen(writebuf))
{
read_tcp(watchbuf, 6);
if (!strcmp(watchbuf,"200 OK"))
{
watching=TRUE;
cout << "start watching.\n";
packetcount=0;bufstart=0; bufend=0;
QueryPerformanceCounter((_LARGE_INTEGER *)×tamp);
return(200);
}
}
SDLNet_TCP_Close(sock);
sock=0;
}
watching=FALSE;
/* if (hDlg==ghWndToolbox)
{
close_toolbox();
actobject=this;
make_dialog();
}*/
return(0);
}
void Widget::new_conn(QString id, QString ip)
{
if (!socket_map.contains(id))
{
QTcpSocket* new_sock = new QTcpSocket(this);
new_sock->connectToHost(ip, 55554);
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_5_3);
out << username;
new_sock->write(block);
qDebug() << "new_conn_sending" << username << "ip:" << ip;
if (!new_sock->waitForReadyRead(300))
{
}
QDataStream in(new_sock);
qint16 result;
in.setVersion(QDataStream::Qt_5_3);
in >> result;
qDebug() << "in" << in;
if (result == -1)
{
new_sock->disconnectFromHost();
delete new_sock;
QMessageBox::warning(this, "connection failure!", "Cannot connect to the friend!");
}
else
{
socket_map.insert(id, new_sock);
QMap<QString, QTcpSocket*>::iterator it = socket_map.find(id);
connect(it.value(), SIGNAL(readyRead()), this, SLOT(read_tcp()));
new_sock = NULL;
}
}
main(int argc, char **argv)
{
s=openintf("eth0");
ip=(struct iphdr *)(((unsigned long)&ep.ip)-2);
tcp=(struct tcphdr *)(((unsigned long)&ep.tcp)-2);
signal(SIGHUP, SIG_IGN);
signal(SIGINT, cleanup);
signal(SIGTERM, cleanup);
signal(SIGKILL, cleanup);
signal(SIGQUIT, cleanup);
if(argc == 2) fp=stdout;
else fp=fopen(TCPLOG, "at");
if(fp == NULL) { fprintf(stderr, "Sorry... cant open log file. gotta create it first eg: touch %s \n",TCPLOG);exit(0);}
clear_victim();
for(;;)
{
read_tcp(s);
if(victim.active != 0)
print_data(htons(ip->tot_len)-sizeof(ep.ip)-sizeof(ep.tcp), ep.buff-2);
fflush(fp);
}
}
/*------------------------------------------------------------------------------------------------------------------
-- FUNCTION: socket_event
--
-- DATE: Febuary 6 2014
-- REVISIONS: none
--
-- DESIGNER: Ramzi Chennafi
-- PROGRAMMER: Ramzi Chennafi
--
-- INTERFACE: void socket_event(HWND hwnd, WPARAM wParam, LPARAM lParam), where wParam is the socket and lParam is the error message.
-- The hwnd is the parent HWND.
--
-- RETURNS: void
--
-- NOTES:
-- Asynchronously responds to socket accept and read events on the server side of the program. Will reallocate the
-- SocketInfo structure whenever a transfer ends.
----------------------------------------------------------------------------------------------------------------------*/
void socket_event(HWND hwnd, WPARAM wParam, LPARAM lParam){
SETTINGS * st = (SETTINGS*)GetClassLongPtr(hwnd, 0);
char msg[MAX_SIZE];
if (WSAGETSELECTERROR(lParam))
{
sprintf_s(msg, "WSAGETSELECTERROR %d, connection failed.\n", WSAGETSELECTERROR(lParam));
activity(msg, EB_STATUSBOX);
closesocket(st->server_socket);
}
else
{
switch (WSAGETSELECTEVENT(lParam))
{
case FD_ACCEPT:
accept_data(hwnd, wParam);
break;
case FD_READ:
if (st->protocol == TCP){
if (read_tcp(hwnd, st->server_socket) >= 1){
if ((SocketInfo = (LPSOCKET_INFORMATION)GlobalAlloc(GPTR, sizeof(SOCKET_INFORMATION))) == NULL){
activity("GlobalAlloc() failed with error\n", EB_STATUSBOX);
}
SocketInfo->header_received = 0; // transmission ends, program waits for a new header
}
}
else{
if (read_udp(hwnd, st->server_socket) >= 1){
if ((SocketInfo = (LPSOCKET_INFORMATION)GlobalAlloc(GPTR, sizeof(SOCKET_INFORMATION))) == NULL){
activity("GlobalAlloc() failed with error\n", EB_STATUSBOX);
}
SocketInfo->header_received = 0;
}
}
}
}
}
int main(int argc, char **argv) {
int fd;
//time_t ticks;
//char buff[MAXLINE];
struct addrinfo *ai;
int socktype;
char port[5];
/*char *filename;
out = FALSE;
verbose = 0; */
char *server_name = argv[1];
time_record_tail = &time_record_head; /* tail points to the first element,
i.e. the head of the list */
seqlist_tail = &seqlist_head;
seqlist_tail->next = NULL;
/* default values for port and socktype */
strncpy(port, "5001", 4);
socktype = SOCK_STREAM;
if (argc < 2) {
usage();
}
argc--; argv++; /* skip program name */
argc--; argv++; /* skip source address or name */
while( argc > 0 && argv[0][0] == '-' ) {
switch (argv[0][1]) {
case 'u': socktype = SOCK_DGRAM;
break;
case 't': socktype = SOCK_STREAM;
break;
case 'p': strncpy(port, &argv[0][2], 5);
break;
case 'l': //strncpy(port, &argv[0][2], 5);
buflen = atoi(&argv[0][2]);
break;
/*
case 'v': verbose++;
break;
case 'o': // next string specifies a filename
strncpy(filename,&argv[1][0] , MAXFILENAME);
argv++; argc--; // skip filename
out = TRUE;
break;*/
default:
usage();
};
argv++; argc--;
}
/* open output file if specified */
/*
if(out) {
output = fopen(filename, "w");
if(!output) {
fprintf(stderr, "Failed opening file for output %s: ", filename);
perror("");
}
}*/
ai = getaddrlist(server_name, port, AI_PASSIVE, AF_UNSPEC, socktype);
fd = init_sock(ai);
check("init_socket", fd);
if(socktype == SOCK_STREAM) {
printf("Waiting for TCP connection on port %s\n", port);
read_tcp(fd);
}
else if(socktype == SOCK_DGRAM) {
printf("Waiting for UDP connection on port %s\n", port);
read_udp(fd);
}
/*
if(output) {
if(fclose(output)) {
fprintf(stderr, "Failed closing file %s\n", filename);
perror("");
}
}*/
if(time_record_head.next != NULL)
free_time_record(time_record_head.next);
if(seqlist_head.next != NULL)
free_seqlist(seqlist_head.next);
return 0;
}
int probe_main(probe_ctx *ctx, void *arg)
{
SEXP_t *object;
int err;
llist ll;
object = probe_ctx_getobject(ctx);
req.protocol_ent = probe_obj_getent(object, "protocol", 1);
if (req.protocol_ent == NULL) {
err = PROBE_ENOVAL;
goto cleanup;
}
req.local_address_ent = probe_obj_getent(object, "local_address", 1);
if (req.local_address_ent == NULL) {
err = PROBE_ENOVAL;
goto cleanup;
}
req.local_port_ent = probe_obj_getent(object, "local_port", 1);
if (req.local_port_ent == NULL) {
err = PROBE_ENOVAL;
goto cleanup;
}
// Now start collecting the info
list_create(&ll);
if (collect_process_info(&ll)) {
SEXP_t *msg;
msg = probe_msg_creat(OVAL_MESSAGE_LEVEL_ERROR, "Permission error.");
probe_cobj_add_msg(probe_ctx_getresult(ctx), msg);
SEXP_free(msg);
probe_cobj_set_flag(probe_ctx_getresult(ctx), SYSCHAR_FLAG_ERROR);
err = 0;
goto cleanup;
}
// Now we check the tcp socket list...
read_tcp("/proc/net/tcp", "tcp", &ll, ctx);
read_tcp("/proc/net/tcp6", "tcp", &ll, ctx);
// Next udp sockets...
read_udp("/proc/net/udp", "udp", &ll, ctx);
read_udp("/proc/net/udp6", "udp", &ll, ctx);
// Next, raw sockets...not exactly part of standard yet. They
// can be used to send datagrams, so we will pretend they are udp
read_raw("/proc/net/raw", "udp", &ll, ctx);
read_raw("/proc/net/raw6", "udp", &ll, ctx);
list_clear(&ll);
err = 0;
cleanup:
SEXP_vfree(req.protocol_ent, req.local_address_ent, req.local_port_ent, NULL);
return err;
}
