Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Scorpion Messenger1.0 (repacking 04012008) - Server.c

Server.c

 Caricato da: ScorpionITA
Scarica il programma completo

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<windows.h>
  4. #include<winsock.h>
  5.  
  6. #define NUMBER_MAX_CLIENT 1000
  7. #define TIMEOUT 800
  8. #define nick "Server: "
  9. #define INVIO   0x0D
  10.  
  11. int chiudi=1;
  12. int dclient[NUMBER_MAX_CLIENT];
  13.  
  14. int Protocol_Gst(char buffer[500],int l_buffrecv,int IDclient);
  15. int SendToOther(char buffer[500],int IDCsend);
  16. int GetText(char *szBuffer, int nMaxLenght);
  17. int Config (int IDconf, char Param[50]);
  18. int SetNick(char Nick[50],int IDclient);
  19. int SendToAll(char buffer[500]);
  20. int Logga(char buffer[500]);
  21. int menu(int IDmenu);
  22.  
  23. SOCKET miosock,acceptsock,pieno,client[NUMBER_MAX_CLIENT];
  24. struct sockaddr_in miosock_addr,client_addr;
  25. WSADATA data;
  26. WORD p;
  27. int len(char *);
  28. int lun, err=0;
  29. int n;
  30. int i;
  31. int gt;
  32. int Log;
  33. int Rmenu;
  34. int ChatMode;
  35. int ServerON=1;
  36. int MAX_CLIENT;
  37. int timeout[NUMBER_MAX_CLIENT];
  38. int ClientLogged[NUMBER_MAX_CLIENT];
  39. int passparam;
  40. int ClientConn=0;
  41. char nickclient[NUMBER_MAX_CLIENT][50];
  42. char buffersend[500];
  43. char Clear_line[500];
  44. char logfile[1000];
  45. SYSTEMTIME LocalTime;
  46.  
  47. DWORD dwThreadClientId[NUMBER_MAX_CLIENT],dwThreadInvioId,dwThreadAcceptClientId, dwThrdParam = 1;
  48.  
  49. HANDLE ThClient[NUMBER_MAX_CLIENT];
  50. HANDLE ThInvio;
  51. HANDLE AcceptConn;
  52.  
  53. DWORD ricezione (LPDWORD lpdwParam)
  54. {
  55.         int IDclient = passparam;
  56.         ClientConn++;
  57.         timeout[IDclient] = clock() + TIMEOUT;
  58.         int r;
  59.         int count = 0;
  60.         char bufferrecv[503];
  61.         char NickBuf[53];
  62.         char temp[100];
  63.  
  64.         strcpy(nickclient[IDclient], "NULL");
  65.         while ((strcmp(nickclient[IDclient], "NULL" )) == 0)
  66.         {
  67.                 if (count >= 5)
  68.                 {
  69.                         send(client[IDclient], "105 Numero di tentativi massimi raggiunto\n", 41, 0);
  70.                         send(client[IDclient], "192 Disconnect", 14, 0);
  71.                         sleep(10);
  72.                         dclient[IDclient] = 0;
  73.  
  74.                         break;
  75.                 }
  76.  
  77.                 else
  78.                 {
  79.                         send(client[IDclient],"105 \nInserisci un nick(max 50 car.): ", 37, 0);
  80.                         n = 0;
  81.                         NickBuf[0] = 0;
  82.                         n = recv(client[IDclient], NickBuf, 53, 0);
  83.                         NickBuf[n] = 0;
  84.                         r = SetNick(NickBuf, IDclient);
  85.  
  86.                         if (r == 0)
  87.                         {
  88.                                 ClientLogged[IDclient] = 0;
  89.                                 send(client[IDclient], "110 NICK OK\r", 12, 0);
  90.                                 /*sprintf(temp, "140 %i", IDclient);
  91.                                   int c = strlen(temp);
  92.                                   send(client[IDclient], temp, c, 0);*/
  93.                                 sprintf(temp, "105 \n%s CONNESSO\n\n", NickBuf);
  94.                                 SendToOther(temp, IDclient);
  95.                                 if (Log == 0){
  96.                                         sprintf(temp, "%s CONNESSO\n\n", NickBuf);
  97.                                         Logga(temp);
  98.                                         }
  99.  
  100.                                 if (ChatMode == 0)
  101.                                         printf("\n%s CONNESSO\n\n", NickBuf);
  102.                         }
  103.  
  104.                         if (r != 0)
  105.                                 send(client[IDclient], "105 Nick gia' in uso\n", 22, 0);
  106.                 }
  107.  
  108.                 count++;
  109.                 sleep(1);
  110.         }
  111.  
  112.         while (dclient[IDclient] != 0)
  113.         {
  114.                 n = 0;
  115.                 bufferrecv[0] = 0;
  116.                 n = recv(client[IDclient], bufferrecv, 500, 0);
  117.                 bufferrecv[n] = 0;
  118.  
  119.                 if (gt > 0)
  120.                 {
  121.                         int b = gt;
  122.                         Clear_line[b] = 0;
  123.  
  124.                         for(b = gt; b >= 0; b--)
  125.                         {
  126.                                 Clear_line[b] = ' ';
  127.                         }
  128.  
  129.                         printf("\r%s\r", Clear_line);
  130.                         Protocol_Gst(bufferrecv, n, IDclient);
  131.                         char buffer[500];
  132.                         int c = gt;
  133.                         strcpy(buffer, buffersend);
  134.                         buffer[c] = 0;
  135.                         printf("%s", buffer);
  136.                 }
  137.  
  138.                 else
  139.                         Protocol_Gst(bufferrecv, n, IDclient);
  140.  
  141.                 sleep(1);
  142.         }
  143.  
  144.         if (ClientLogged[IDclient] == 0)
  145.         {
  146.                 sprintf(temp, "105 \n%s SCONNESSO\n\n", NickBuf);
  147.                 SendToOther(temp, IDclient);
  148.  
  149.                 if (Log == 0){
  150.                         sprintf(temp, "%s SCONNESSO\n\n", NickBuf);
  151.                         Logga(temp);
  152.                         }
  153.  
  154.                 if (ChatMode == 0)
  155.                         printf("\n%s SCONNESSO\n\n", NickBuf);
  156.         }
  157.  
  158.         send(client[IDclient], "192 Disconnect", 14, 0);
  159.         ClientLogged[IDclient] = 1;
  160.         ClientConn--;
  161.         strcpy(nickclient[IDclient], "NULL");
  162.         closesocket(client[IDclient]);
  163.         client[IDclient] = SOCKET_ERROR;
  164.  
  165.         return 0;
  166. }
  167.  
  168. DWORD invio (LPDWORD lpdwParam)
  169. {
  170.         int z;
  171.         char temp[500];
  172.  
  173.         while (chiudi != 0)
  174.         {
  175.                 buffersend[0] = 0;
  176.                 z = GetText(buffersend, 500);
  177.  
  178.                 if (z == 2)
  179.                         break;
  180.  
  181.                 z = strlen(buffersend);
  182.                 sprintf(temp, "105 %s: %s", nick, buffersend);
  183.                 z = strlen(temp);
  184.                 SendToAll(temp);
  185.  
  186.                 sleep(3);
  187.         }
  188.  
  189.         return 0;
  190. }
  191.  
  192. DWORD AcceptClient (LPDWORD lpdwParam)
  193. {
  194.         while (ServerON == 0)
  195.         {
  196.                 acceptsock = SOCKET_ERROR;
  197.                 acceptsock = accept(miosock, 0, 0);
  198.  
  199.                 if (ClientConn >= MAX_CLIENT)
  200.                 {
  201.                         pieno = acceptsock;
  202.                         send(pieno, "105 \nServer pieno", 17, 0);
  203.  
  204.                         sleep(3);
  205.                         closesocket(pieno);
  206.                 }
  207.  
  208.                 else
  209.                 {
  210.                         for (i = 1; i <= MAX_CLIENT; i++)
  211.                         {
  212.                                 if (client[i] == SOCKET_ERROR)
  213.                                 {
  214.                                         client[i] = acceptsock;
  215.  
  216.                                         if (client[i] != SOCKET_ERROR)
  217.                                         {
  218.                                                 passparam = i;
  219.                                                 dclient[i] = 1;
  220.                                                 ThClient[i] = CreateThread(NULL,
  221.                                                                           0, (LPTHREAD_START_ROUTINE) ricezione,
  222.                                                                           &dwThrdParam, 0,
  223.                                                                           &dwThreadClientId[i]);
  224.                                         }
  225.  
  226.                                         break;
  227.                                         closesocket(acceptsock);
  228.                                 }
  229.  
  230.                                 sleep(1);
  231.                         }
  232.                 }
  233.  
  234.                 sleep(1);
  235.         }
  236.  
  237.         return 0;
  238. }
  239.  
  240.  
  241.  
  242. int main (int argn, char **argv)
  243. {
  244.         Title();
  245.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  246.         printf("\nCaricamento in corso...");
  247.  
  248.         for (i = 0; i <= NUMBER_MAX_CLIENT; i++)
  249.         {
  250.                 client[i] = SOCKET_ERROR;
  251.         }
  252.  
  253.         printf("...");
  254.  
  255.         for (i = 0; i <= NUMBER_MAX_CLIENT; i++)
  256.         {
  257.                 ClientLogged[i] = 1;
  258.         }
  259.  
  260.         printf("...");
  261.         chiudi = 1;
  262.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  263.         printf("...");
  264.         Config(0, 0);
  265.         printf("...");
  266.         printf(" OK\n\n");
  267.  
  268.         while (chiudi != 0)
  269.         {
  270.                 Rmenu = menu(0);
  271.  
  272.  
  273.                 if (Rmenu == 1)
  274.                 {
  275.                         for (i = 0; i <= MAX_CLIENT; i++)
  276.                         {
  277.                                 closesocket(client[i]);
  278.                         }
  279.  
  280.                 closesocket(miosock);
  281.                 WSACleanup();
  282.                 break;
  283.                 }
  284.         }
  285.  
  286.         return 0;
  287. }
  288.  
  289. int Protocol_Gst (char buffer[500], int l_buffrecv, int IDclient)
  290. {
  291.         char Com_Mess[3] = "000";
  292.  
  293.         Com_Mess[0] = buffer[0];
  294.         Com_Mess[1] = buffer[1];
  295.         Com_Mess[2] = buffer[2];
  296.         Com_Mess[3] = 0;
  297.  
  298.         if ((strcmp(Com_Mess, "105")) == 0)
  299.         {
  300.                 char temp[500];
  301.                 int i = 0;
  302.                 int c;
  303.  
  304.                 for(c = 4; c <= l_buffrecv; c++)
  305.                 {
  306.                         temp[i] = buffer[c];
  307.                         i++;
  308.                 }
  309.  
  310.                 temp[i] = 0;
  311.                 sprintf(buffer, "105 %s : %s", nickclient[IDclient], temp);
  312.                 SendToOther(buffer, IDclient);
  313.                 sprintf(buffer, "%s : %s", nickclient[IDclient], temp);
  314.                 if (Log == 0)
  315.                         Logga(buffer);
  316.                 if (ChatMode == 0)
  317.                         printf("%s", buffer);
  318.  
  319.                 timeout[IDclient]=clock()+TIMEOUT;
  320.         }
  321.  
  322.         else if ((strcmp(Com_Mess, "165")) == 0)
  323.         {
  324.                 int error = 1;
  325.                 char temp[500];
  326.                 int b = l_buffrecv - 4;
  327.                 char buf[b];
  328.                 int c = 0;
  329.  
  330.                 for (b = 5; b <= l_buffrecv; b++)
  331.                 {
  332.                         buf[c] = buffer[b];
  333.                         c++;
  334.                 }
  335.  
  336.                 c = c - 2;
  337.                 buf[c] = 0;
  338.  
  339.                 /* Commands without parameters */
  340.                 if ((strcmp(buf, "listclient")) == 0)
  341.                 {
  342.                         sprintf(temp, "105 \n\nID Client \t\t Nickname\n\n    %i \t\t\t %s\n", IDclient, nickclient[IDclient]);
  343.                         b = strlen(temp);
  344.                         temp[b] = 0;
  345.                         send(client[IDclient], temp, b, 0);
  346.                         int IDC;
  347.  
  348.                         for (IDC = 0; IDC <= MAX_CLIENT; IDC++)
  349.                         {
  350.                                 if (IDC != IDclient)
  351.                                 {
  352.                                         if (ClientLogged[IDC] != 1)
  353.                                         {
  354.                                                 sprintf(temp, "105     %i \t\t\t %s\n", IDC, nickclient[IDC]);
  355.                                                 b = strlen(temp);
  356.                                                 send(client[IDclient], temp, b, 0);
  357.                                         }
  358.                                                                                                                                 }
  359.                                         sleep(1);
  360.                                 }
  361.  
  362.                                 send(client[IDclient],"105 \n\n", 6, 0);
  363.                                 error = 0;
  364.                         }
  365.  
  366.                         else if ((strcmp(buf, "help")) == 0)
  367.                         {
  368.                                 send(client[IDclient], "105 \nElenco Comandi:\n\n", 21, 0);
  369.                                 send(client[IDclient], "105 /help\t-> Mostra l'elenco comandi\n", 45, 0);
  370.                                 send(client[IDclient], "105 /listclient\t-> Mostra la lista dei client conessi con i rispettivi ID\n", 76, 0);
  371.                                 send(client[IDclient], "105 /pm\t-> permette di inviare pm sintassi: \"/pm ID client Messaggio\"\n\n", 81, 0);
  372.                                 error = 0;
  373.                         }
  374.  
  375.                         /* Commands with parameters */
  376.                         else {
  377.                                 temp[0] = buf[0];
  378.                                 temp[1] = buf[1];
  379.                                 temp[2] = 0;
  380.  
  381.                                 if ((strcmp(temp, "pm")) == 0)
  382.                                 {
  383.                                         int IdSendPm;
  384.                                         char TextSendPm[500];
  385.                                         c = 0;
  386.  
  387.                                         for (b = 3; buf[b] != ' '; b++)
  388.                                         {
  389.                                                 temp[c] = buf[b];
  390.                                                 c++;
  391.  
  392.                                                 if(b>l_buffrecv-4)
  393.                                                 {
  394.                                                         send(client[IDclient], "105 \nErrore 180\n", 16, 0);
  395.  
  396.                                                         return 1;
  397.                                                 }
  398.                                         }
  399.  
  400.                                         temp[c] = 0;
  401.                                         IdSendPm = atoi(temp);
  402.  
  403.                                         if(IdSendPm == IDclient)
  404.                                         {
  405.                                                 send(client[IDclient], "105 \nImpossibile inviare un pm a se stessi\n", 44, 0);
  406.  
  407.                                                 return 1;
  408.                                         }
  409.  
  410.                                         c=0;
  411.  
  412.                                         for (b = b + 1; buf[b]; b++)
  413.                                         {
  414.                                                 TextSendPm[c] = buf[b];
  415.                                                 c++;
  416.                                         }
  417.  
  418.                                         TextSendPm[c] = 0;
  419.                                         sprintf(temp, "105 Messaggio Privato da %s(%i): %s\n",
  420.                                                 nickclient[IDclient], IDclient, TextSendPm);
  421.  
  422.                                         c = strlen(temp);
  423.                                         temp[c] = 0;
  424.                                         send(client[IdSendPm], temp, c, 0);
  425.                                         error=0;
  426.                                 }
  427.                         }
  428.  
  429.                         if (error != 0)
  430.                                 send(client[IDclient], "105 Comando Errato\n\n", 20, 0);
  431.  
  432.                         timeout[IDclient] = clock() + TIMEOUT;
  433.                 }
  434.  
  435.         else if ((strcmp(Com_Mess, "180")) == 0)
  436.                 timeout[IDclient] = clock() + TIMEOUT;
  437.  
  438.         else if ((strcmp(Com_Mess, "192")) == 0)
  439.                 dclient[IDclient] = 0;
  440.  
  441.         else if (timeout[IDclient] <= clock())
  442.                 dclient[IDclient] = 0;
  443.  
  444.         return 0;
  445. }
  446.  
  447. int SetNick (char NickCli[50], int IDclient)
  448. {
  449.         int IDC = 0;
  450.         int ln = 0;
  451.         char Nick[50];
  452.         char Buf_Nick[50];
  453.  
  454.         for (ln = 0; NickCli[ln]; ln++)
  455.         {
  456.                 Nick[ln] = tolower(NickCli[ln]);
  457.         }
  458.  
  459.         Nick[ln] = 0;
  460.  
  461.         for (IDC = 0; IDC <= MAX_CLIENT; IDC++)
  462.         {
  463.                 for (ln = 0; nickclient[IDC][ln]; ln++)
  464.                 {
  465.                         Buf_Nick[ln] = tolower(nickclient[IDC][ln]);
  466.                 }
  467.  
  468.                 Buf_Nick[ln] = 0;
  469.  
  470.                 if ((strcmp(Buf_Nick,Nick)) == 0)
  471.                 {
  472.                         return 1;
  473.                 }
  474.  
  475.                 sleep(1);
  476.         }
  477.  
  478.         strcpy(nickclient[IDclient],NickCli);
  479.  
  480.         return 0;
  481. }
  482.  
  483. int SendToAll (char buffer[500])
  484. {
  485.         int lstring = strlen(buffer);
  486.         int IDC;
  487.  
  488.         for (IDC = 1; IDC <= MAX_CLIENT; IDC++)
  489.         {
  490.                 if (ClientLogged[IDC] != 1)
  491.                 {
  492.                         send(client[IDC], buffer, lstring, 0);
  493.                 }
  494.  
  495.                 sleep(1);
  496.         }
  497.  
  498.         return 0;
  499. }
  500.  
  501. int SendToOther (char buffer[500], int IDCsend)
  502. {
  503.         int lstring = strlen(buffer);
  504.         int IDC;
  505.  
  506.         for (IDC = 1; IDC <= MAX_CLIENT; IDC++)
  507.         {
  508.                 if (IDC != IDCsend)
  509.                 {
  510.                         if(ClientLogged[IDC] != 1)
  511.                         {
  512.                                 send(client[IDC], buffer, lstring, 0);
  513.                         }
  514.  
  515.                         sleep(1);
  516.                 }
  517.         }
  518.  
  519.         return 0;
  520. }
  521.  
  522. int GetText (char *szBuffer, int nMaxLenght)
  523. {
  524.         gt = 0;
  525.         char ch;
  526.         nMaxLenght - 2;
  527.  
  528.         while (ch != INVIO)
  529.         {
  530.                 ch = getch();
  531.                 if (ChatMode == 0)
  532.                 {
  533.                         if (GetAsyncKeyState(27) == -32767)
  534.                                 return 2;
  535.                 }
  536.  
  537.                 if (gt < 0)
  538.                         gt = 0;
  539.  
  540.                 if (gt > (nMaxLenght))
  541.                         gt = nMaxLenght;
  542.  
  543.                 else
  544.                 {
  545.                         if (ch == '\b')
  546.                         {
  547.                                 if (ch != 0 && gt > 0)
  548.                                         putch('\b');
  549.  
  550.                                 putch(' ');
  551.                                 putch('\b');
  552.                                 gt--;
  553.                         }
  554.  
  555.                         else
  556.                         {
  557.                                 szBuffer[gt++] = ch;
  558.                                 putch(ch);
  559.                         }
  560.                 }
  561.         }
  562.  
  563.         printf("\n");
  564.  
  565.         if (gt == 0)
  566.         {
  567.                 szBuffer[0] = '\n';
  568.                 szBuffer[1] = '\0';
  569.         }
  570.  
  571.         else
  572.         {
  573.                 gt--;
  574.                 szBuffer[gt] = '\n';
  575.                 gt++;
  576.                 szBuffer[gt] = '\0';
  577.         }
  578.  
  579.         gt=0;
  580.         return 0;
  581. }
  582.  
  583. int Logga(char buffer[500]){
  584.         GetLocalTime(&LocalTime);
  585.         FILE *log;
  586.         log=fopen(logfile,"a");
  587.         if(log == NULL)
  588.         {
  589.                 printf("\n\nImpossibile Salvare i log");
  590.         }
  591.         else
  592.         {
  593.                 fprintf(log,"<p><font face=\"Comic Sans MS\" size=\"2\"><%i:%i> %s</font></p>\n",LocalTime.wHour,LocalTime.wMinute,buffer);
  594.                 fclose(log);
  595.         }
  596. return 0;
  597. }
  598.  
  599. int Config (int IDconf, char Param[50])
  600. {
  601.         HKEY chiave;
  602.         DWORD KeyExsist;
  603.         char path[] = "SOFTWARE\\Scorpion Software\\Scorpion Messenger\\Server";
  604.  
  605.         if (IDconf == 0)
  606.         {
  607.                 DWORD ipsize;
  608.                 char Logging[1];
  609.                 char Max_Users[5];
  610.                 RegCreateKeyEx(HKEY_LOCAL_MACHINE, path, 0, NULL,
  611.                                REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
  612.                                &chiave, &KeyExsist);
  613.  
  614.                 if (KeyExsist == REG_CREATED_NEW_KEY)
  615.                 {
  616.                         system("cls");
  617.                         Title();
  618.                         printf("\n*** Prima Configurazione del Programma ***\n\n");
  619.                         printf("\nNumero massimo delle connessioni simultanee: ");
  620.                         GetText(Max_Users, 50);
  621.                         Max_Users[strlen(Max_Users)-1] = 0;
  622.                         MAX_CLIENT = atoi(Max_Users);
  623.                         RegSetValueEx(chiave, "Max Users", 0, REG_SZ, Max_Users, strlen(Max_Users));
  624.                         printf("\nVuoi abilitare il logging della chat?(S/N): ");
  625.                         int ci = 0;
  626.  
  627.                         while ( ci == 0)
  628.                         {
  629.                                 char sc;
  630.                                 sc = getch();
  631.  
  632.                                 if (tolower(sc) == 's')
  633.                                 {
  634.                                         Log = 0;
  635.                                         RegSetValueEx(chiave, "Log", 0, REG_SZ, "0", 1);
  636.                                         ci = 1;
  637.                                 }
  638.  
  639.                                 else if (tolower(sc) == 'n')
  640.                                 {
  641.                                         Log = 1;
  642.                                         RegSetValueEx(chiave, "Log", 0, REG_SZ, "1", 1);
  643.                                         ci = 1;
  644.                                 }
  645.                         }
  646.                 }
  647.                 else
  648.                 {
  649.                         RegQueryValueEx(chiave, "Max Users", NULL, NULL, Max_Users, &ipsize);
  650.                         RegQueryValueEx(chiave, "Log", NULL, NULL, Logging, &ipsize);
  651.                         Log = atoi(Logging);
  652.                         MAX_CLIENT = atoi(Max_Users);
  653.                 }
  654.  
  655.  
  656.                 RegCloseKey(chiave);
  657.         }
  658.  
  659.         else if (IDconf == 1)
  660.         {
  661.                 RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0, KEY_SET_VALUE, &chiave);
  662.                 RegSetValueEx(chiave, "Max Users", 0, REG_SZ, Param, strlen(Param));
  663.                 RegCloseKey(chiave);
  664.         }
  665.  
  666.         else if (IDconf == 2)
  667.         {
  668.                 RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0, KEY_SET_VALUE, &chiave);
  669.                 RegSetValueEx(chiave, "Log", 0, REG_SZ, Param, strlen(Param));
  670.                 RegCloseKey(chiave);
  671.         }
  672.  
  673.         if (Log == 0)
  674.         {
  675.                 ExpandEnvironmentStrings("%USERPROFILE%\\Documenti\\", logfile, sizeof(logfile));
  676.                 strcat(logfile, "Scorpion Messenger");
  677.                 CreateDirectory(logfile, NULL);
  678.                 strcat(logfile, "Scorpion Messenger\\Server");
  679.                 CreateDirectory(logfile, NULL);
  680.                 GetLocalTime(&LocalTime);
  681.                 char temp[500];
  682.                 sprintf(temp, "\\Log_%i_%i_%i.htm", LocalTime.wDay, LocalTime.wMonth, LocalTime.wYear);
  683.                 strcat(logfile, temp);
  684.         }
  685.  
  686.         return 0;
  687. }
  688.  
  689. int menu (int IDmenu)
  690. {
  691.         int scelta;
  692.         int CicloMenu;
  693.         int cm;
  694.         ChatMode = 1;
  695.         while (1)
  696.         {
  697.                 if (IDmenu == 0)
  698.                 {
  699.                         scelta = 0;
  700.                         char ScelteMenu0[4][30];
  701.  
  702.                         if (ServerON == 0)
  703.                         {
  704.                                 strcpy(ScelteMenu0[0], "Ferma il Server");
  705.                         }
  706.  
  707.                         else
  708.                                 strcpy(ScelteMenu0[0], "Avvia il Server");
  709.  
  710.                         strcpy(ScelteMenu0[1], "Entra in chat");
  711.                         strcpy(ScelteMenu0[2], "Impostazioni");
  712.                         strcpy(ScelteMenu0[3], "Credits & Info");
  713.                         strcpy(ScelteMenu0[4], "Esci");
  714.  
  715.                         CicloMenu = 0;
  716.  
  717.                         while (CicloMenu == 0)
  718.                         {
  719.                                 if (GetAsyncKeyState(38) == -32767)
  720.                                 {
  721.                                         if (scelta == 0)
  722.                                                 scelta = 4;
  723.  
  724.                                         else
  725.                                                 scelta--;
  726.                                 }
  727.  
  728.                                 else if (GetAsyncKeyState(40) == -32767)
  729.                                 {
  730.                                         if (scelta == 4)
  731.                                                 scelta = 0;
  732.  
  733.                                         else
  734.                                                 scelta++;
  735.                                 }
  736.  
  737.                                 else if (GetAsyncKeyState(13) == -32767)
  738.                                 {
  739.                                         if (scelta == 0)
  740.                                         {
  741.                                                 system("cls");
  742.                                                 Title();
  743.                                                 if (ServerON == 0)
  744.                                                 {
  745.                                                         ServerON = 1;
  746.                                                         strcpy(ScelteMenu0[0], "Avvia il Server");
  747.                                                         TerminateThread(AcceptConn,0);
  748.  
  749.                                                         for (i = 0; i <= MAX_CLIENT; i++)
  750.                                                                 closesocket(client[i]);
  751.  
  752.                                                         closesocket(miosock);
  753.                                                         WSACleanup();
  754.                                                 }
  755.  
  756.                                                 else
  757.                                                 {
  758.                                                         ServerON = 0;
  759.                                                         strcpy(ScelteMenu0[0], "Ferma il Server");
  760.                                                         p = MAKEWORD(2, 0);
  761.                                                         err=WSAStartup(p, &data);
  762.  
  763.                                                         miosock=socket(PF_INET, SOCK_STREAM, 0);
  764.  
  765.                                                         miosock_addr.sin_family = PF_INET;
  766.                                                         miosock_addr.sin_port = htons(65);
  767.                                                         miosock_addr.sin_addr.s_addr = INADDR_ANY;
  768.                                                         err = bind(miosock, (struct sockaddr*) &miosock_addr, sizeof(struct sockaddr_in));
  769.                                                         err = listen(miosock,1);
  770.                                                         lun = sizeof (struct sockaddr);
  771.  
  772.                                                         AcceptConn = CreateThread(NULL, 0,(LPTHREAD_START_ROUTINE) AcceptClient, &dwThrdParam, 0, &dwThreadAcceptClientId);
  773.                                                 }
  774.                                         }
  775.                                        
  776.                                         else if (scelta == 1)
  777.                                         {
  778.                                                 system("cls");
  779.                                                 Title();
  780.  
  781.                                                 if (ServerON == 0)
  782.                                                 {
  783.                                                         printf("\nPer uscire dalla Modalit%c Chat premete il tasto \"Esc\"\n", -123);
  784.                                                         system("pause");
  785.                                                         system("cls");
  786.                                                         Title();
  787.                                                         printf("\n\n");
  788.                                                         ChatMode = 0;
  789.                                                         ThInvio = CreateThread(NULL, 0,(LPTHREAD_START_ROUTINE) invio, &dwThrdParam, 0, &dwThreadInvioId);
  790.                                                         WaitForSingleObject(ThInvio, INFINITE);
  791.                                                         ChatMode = 1;
  792.                                                 }
  793.  
  794.                                                 else
  795.                                                 {
  796.                                                         printf("\nNon si pu%c entrare in chat se il server non %c attivo\n", -107, -118);
  797.                                                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  798.                                                         printf("\n\n-> Indietro <-\n");
  799.                                                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  800.                                                                 while (GetAsyncKeyState(13) != -32767);
  801.                                                 }
  802.                                         }
  803.  
  804.                                         else if (scelta == 2)
  805.                                         {
  806.                                                 IDmenu = 1;
  807.                                                 break;
  808.                                         }
  809.  
  810.                                         else if (scelta == 3)
  811.                                         {
  812.                                                 system("cls");
  813.                                                 Title();
  814.                                                 printf("\nScorpion Messenger 1.0");
  815.                                                 printf("\n\t\tBy Scorpion");
  816.                                                 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  817.                                                 printf("\n\n-> Indietro <-\n");
  818.                                                 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),10);
  819.                                                 while (GetAsyncKeyState(13) != -32767);
  820.                                         }
  821.  
  822.                                         else if (scelta == 4)
  823.                                         {
  824.                                                 system("cls");
  825.                                                 Title();
  826.                                                 printf("\nArrivederci!!!");
  827.                                                 sleep(1000);
  828.                                                 chiudi = 0;
  829.                                                 return 1;
  830.                                         }
  831.                                 }
  832.  
  833.                                 system("cls");
  834.                                 Title();
  835.                                 printf("\t*** Main Men%c ***\n\n", -105);
  836.  
  837.                                 for (cm = 0; cm <= 4; cm++)
  838.                                 {
  839.                                         if(cm == scelta)
  840.                                         {
  841.                                                 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  842.                                                 printf("\t-> %s <-\n", ScelteMenu0[cm]);
  843.                                                 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  844.                                         }
  845.  
  846.                                         else
  847.                                                 printf("\t  %s\n",ScelteMenu0[cm]);
  848.                                 }
  849.  
  850.                                 sleep(5);
  851.                                 getch();
  852.                         }
  853.                 }
  854.  
  855.         if(IDmenu == 1)
  856.         {
  857.                 scelta = 0;
  858.                 char ScelteMenu1[3][80];
  859.                 strcpy(ScelteMenu1[0], "Setta il numero massimo delle connessioni simultanee");
  860.                 if (Log != 0)
  861.                         strcpy(ScelteMenu1[1], "Abilita salvataggio log");
  862.  
  863.                 else
  864.                         strcpy(ScelteMenu1[1], "Disabilita salvataggio log");
  865.  
  866.                 strcpy(ScelteMenu1[2], "Indietro");
  867.                 CicloMenu = 0;
  868.         while (CicloMenu == 0)
  869.                 {
  870.                         if (GetAsyncKeyState(38) == -32767)
  871.                         {
  872.                                 if (scelta == 0)
  873.                                         scelta = 2;
  874.  
  875.                                 else
  876.                                         scelta--;
  877.                         }
  878.  
  879.                         else if (GetAsyncKeyState(40) == -32767)
  880.                         {
  881.                                 if (scelta == 2)
  882.                                         scelta=0;
  883.  
  884.                                 else
  885.                                         scelta++;
  886.                         }
  887.  
  888.                         else if (GetAsyncKeyState(13) == -32767)
  889.                         {
  890.                                 if (scelta == 0)
  891.                                 {
  892.                                         fflush(stdin);
  893.                                         system("cls");
  894.                                         Title();
  895.                                         if (ServerON == 0)
  896.                                         {
  897.                                                 printf("\nPrima di cambiare il limite delle conessioni massime simultanee devi fermare il server");
  898.                                                 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  899.                                                 printf("\n\n-> Indietro <-\n");
  900.                                                 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  901.                                                 while (GetAsyncKeyState(13) != -32767);
  902.                                                
  903.                                         }
  904.                                         else
  905.                                         {
  906.                                                 printf("\nLimite Corrente: \"%i\"", MAX_CLIENT);
  907.                                                 printf("\nVuoi Cambiare?(S/N): ");
  908.                                                 int ci = 0;
  909.                                                 while (ci == 0)
  910.                                                 {
  911.                                                         char sc = getch();
  912.                                                         if (tolower(sc) == 's')
  913.                                                         {
  914.                                                                 putch(sc);
  915.                                                                 char Temp[4];
  916.                                                                 int temp;
  917.                                                                 int cl = 0;
  918.                                                                 while (cl == 0)
  919.                                                                 {
  920.                                                                         printf("\n\nInserisci il numero massimo delle connessioni simultanee(max %i): ", NUMBER_MAX_CLIENT);
  921.                                                                         GetText(Temp, 4);
  922.                                                                         Temp[strlen(Temp) - 1] = 0;
  923.                                                                         temp = atoi(Temp);
  924.  
  925.                                                                         if (temp > NUMBER_MAX_CLIENT)
  926.                                                                                 printf("\nErrore, Massimo %i Utenti",NUMBER_MAX_CLIENT);
  927.  
  928.                                                                         else if (temp < 0)
  929.                                                                                 printf("\nErrore 195");
  930.                                                                         else
  931.                                                                         {
  932.                                                                                 MAX_CLIENT = temp;
  933.                                                                                 Config(1, Temp);
  934.                                                                                 cl = 1;
  935.                                                                         }
  936.                                                                        
  937.                                                                 }
  938.                                                         ci = 1;
  939.                                                         }
  940.                                                         else if (tolower(sc) == 'n')
  941.                                                         {
  942.                                                                 putch(sc);
  943.                                                                 ci = 1;
  944.                                                         }
  945.                                                 }
  946.                                         }
  947.                                 }
  948.                                 else if (scelta == 1)
  949.                                 {
  950.                                         if (Log == 0)
  951.                                         {
  952.                                                 Log = 1;
  953.                                                 Config(2, "1");
  954.                                                 strcpy(ScelteMenu1[1], "Abilita salvataggio log");
  955.                                         }
  956.  
  957.                                         else
  958.                                         {
  959.                                                 Log = 0;
  960.                                                 Config(2, "0");
  961.                                                 strcpy(ScelteMenu1[1], "Disabilita salvataggio log");
  962.                                         }
  963.                                 }
  964.  
  965.                                 else if (scelta == 2)
  966.                                 {
  967.                                 IDmenu=0;
  968.                                 break;
  969.                                 }
  970.                         }
  971.                         system("cls");
  972.                         Title();
  973.                         printf("\t*** Impostazioni ***\n\n");
  974.  
  975.                         for (cm = 0; cm <= 2; cm++)
  976.                         {
  977.                                 if (cm == scelta)
  978.                                 {
  979.                                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  980.                                         printf("\t-> %s <-\n",ScelteMenu1[cm]);
  981.                                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  982.                                 }
  983.                                 else
  984.                                         printf("\t  %s\n", ScelteMenu1[cm]);
  985.                         }
  986.                         sleep(5);
  987.                         getch();
  988.                 }
  989.         }
  990. }
  991.         return 0;
  992. }
  993.  
  994. int Title()
  995. {
  996.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
  997.         printf("\n*** Scorpion Messenger Ver. 1.0 Server ***\n\n");
  998.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  999. }