Platon Technologies
neprihlásený Prihlásiť Registrácia
SlovakEnglish
open source software development oslavujeme 10 rokov vývoja otvoreného softvéru! Streda, 4. október 2023
[BACK] [TXT][DIR] Vyššie na [Platon] / libplaton / utils / server-backend

Rozdiely pre libplaton/utils/server-backend/server-backend.c medzi verziami 1.2 a 1.3

verzia 1.2, 2002/10/15 22:25:01 verzia 1.3, 2002/10/16 21:04:54
Riadok 34 
Riadok 34 
 /* signal() */  /* signal() */
 #include <signal.h>  #include <signal.h>
   
   #include "utils.h"
 #include "server-backend.h"  #include "server-backend.h"
   
 int main(int argc, char *argv[]) {  int main(int argc, char *argv[])
   {
         register int k;  
         int port;          int port;
         int listen_sock;          int listen_sock;
         fd_set fds;          fd_set fds;
         struct sockaddr_in bind_addr;  
         struct client *client_first = NULL;          struct client *client_first = NULL;
         char **process;          char **process;
         char *fake_argv[] = {  
                 "vim", "parser.h", "parser.c", "config.h", "main.h", "main.c", NULL  
         };  
   
         if (argc < 3) {          if (argc < 3) {
                 fprintf(stderr, "Usage: %s <port> <process> <arg1> ... <argn>\n",                  fprintf(stderr, "Usage: %s <port> <process> <arg1> ... <argn>\n",
                                                                 PROG_NAME);                                  PROG_NAME);
                 return 1;  
         }  
   
         port = atoi(argv[1]);  
         port = port > 0 ? port : PORT;  
   
         process = (char**) malloc((argc - 2 + 1) * sizeof(char*));  
         if (process == NULL) {  
                 perror(PROG_NAME);  
                 return 1;                  return 1;
         }          }
         process[argc - 2] = NULL;  
   
         for (k = 2; k < argc; k++) {  
                 process[k - 2] = strdup(argv[k]);  
                 if (process[k - 2] == NULL) {  
                         perror(PROG_NAME);  
                         return 1;  
                 }  
         }  
   
         /*  
          * Fake command line string.  
          */  
   
         {  
                 int argv_size = 0;  
   
                 for (k = 0; k < argc; k++)  
                         argv_size += strlen(argv[k]) + 1;  
   
                 memset(argv[0], '\0', argv_size);  
   
                 for (k = 0; fake_argv[k] != NULL; k++) {  
                         fprintf(stderr, "argv_size = %d\n", argv_size);  
                         if (argv[k] == NULL)  
                                 break;  
   
                         if (strlen(fake_argv[k]) + 1 <= argv_size) {  
                                 strcpy(argv[k], fake_argv[k]);  
                                 if (argv[k + 1] != NULL)  
                                         argv[k + 1] = argv[k] + strlen(fake_argv[k]) + 1;  
   
                                 argv_size -= strlen(fake_argv[k]) + 1;  
                         }  
                         else {  
                                 strncpy(argv[k], fake_argv[k], argv_size - 1);  
                                 break;  
                         }  
                 }  
         }  
   
         /*          port = get_port(argv[1]);
            (void) setpgrp();  
            signal(SIGBRK, SIG_IGN);  
          */  
   
         listen_sock = socket(AF_INET, SOCK_STREAM, 0);          if ((process = create_process_array(argc, argv, 2)) == NULL) {
   
         if (listen_sock == -1) {  
                 perror(PROG_NAME);                  perror(PROG_NAME);
                 return errno;                  return 32;
         }          }
   
         bind_addr.sin_family = AF_INET;          fake_command_line(argc, argv);
         bind_addr.sin_addr.s_addr = INADDR_ANY;  
         bind_addr.sin_port = htons(port);  
   
         if (bind(listen_sock, (struct sockaddr *) &bind_addr,          if ((listen_sock = bind_to_port(port)) == -1) {
                                                                 sizeof(struct sockaddr_in)) == -1) {  
                 perror(PROG_NAME);                  perror(PROG_NAME);
                 return errno;                  return 16;
         }          }
   
         if (listen(listen_sock, 10)) {          if (0) {
                 perror(PROG_NAME);                  (void) setpgrp();
                 return errno;                  signal(SIGHUP, SIG_IGN);
         }          }
   
         fcntl(listen_sock,F_SETFL,O_NDELAY);          if (1)
                   fcntl(listen_sock,F_SETFL,O_NDELAY);
   
         switch (fork()) {          switch (fork()) {
                 case -1:                  case -1:
Riadok 141  int main(int argc, char *argv[]) {
Riadok 81  int main(int argc, char *argv[]) {
                 case 0:                  case 0:
                         break;                          break;
                 default:                  default:
                         fprintf(stdout, "%s: accepting connections on port %d\n",                          fprintf(stderr, "%s: accepting connections on port %d\n",
                                                                         PROG_NAME, port);                                          PROG_NAME, port);
                         return 0;                          return 0;
                         break;                          break;
         }          }
Riadok 158  int main(int argc, char *argv[]) {
Riadok 98  int main(int argc, char *argv[]) {
                    pid++;                     pid++;
   
                    fprintf(stderr, "debug: %d active clients\n", pid);                     fprintf(stderr, "debug: %d active clients\n", pid);
                  */                     */
   
                 FD_ZERO(&fds);                  FD_ZERO(&fds);
                 FD_SET(listen_sock, &fds);                  FD_SET(listen_sock, &fds);
Riadok 176  int main(int argc, char *argv[]) {
Riadok 116  int main(int argc, char *argv[]) {
                         int accept_sock;                          int accept_sock;
                         struct hostent *host;                          struct hostent *host;
   
                         size = sizeof(struct sockaddr_in);                          size        = sizeof(struct sockaddr_in);
                         accept_sock = accept(listen_sock,                          accept_sock = accept(listen_sock,
                                                                         (struct sockaddr*) &acc_addr, &size);                                          (struct sockaddr*) &acc_addr, &size);
   
                         if (accept_sock > 0 &&                          if (accept_sock > 0 &&
                                                                         (client_new = (struct client*)                                          (client_new = (struct client*)
                                                                          malloc(sizeof(struct client))) != NULL) {                                           malloc(sizeof(struct client))) != NULL) {
   
                                 client_new->fd = accept_sock;                                  client_new->fd = accept_sock;
   
                                 /* Geting client IP address. */                                  /* Geting client IP address. */
                                 strncpy(client_new->ip,                                  strncpy(client_new->ip,
                                                                                 (char*)inet_ntoa(acc_addr.sin_addr),                                                  (char*)inet_ntoa(acc_addr.sin_addr),
                                                                                 IP_SIZE);                                                  IP_SIZE);
                                 client_new->ip[IP_SIZE] = '\0';                                  client_new->ip[IP_SIZE] = '\0';
   
                                 /* Geting host name. */                                  /* Geting host name. */
Riadok 209  int main(int argc, char *argv[]) {
Riadok 149  int main(int argc, char *argv[]) {
                                 }                                  }
                                 else {                                  else {
                                         for (client = client_first;                                          for (client = client_first;
                                                                                         client->next != NULL;                                                          client->next != NULL;
                                                                                         client = client->next)                                                          client = client->next)
                                                 ;                                                  ;
   
                                         client->next = client_new;                                          client->next = client_new;
Riadok 258  int main(int argc, char *argv[]) {
Riadok 198  int main(int argc, char *argv[]) {
   
                                 /*                                  /*
                                    fprintf(stderr, "debug: trying to removing pid %d, comparing with %d\n", pid, client->pid);                                     fprintf(stderr, "debug: trying to removing pid %d, comparing with %d\n", pid, client->pid);
                                  */                                     */
   
                                 if (client->pid == pid) {                                  if (client->pid == pid) {
   
                                         /*                                          /*
                                            fprintf(stderr, "debug: removing pid %d\n", pid);                                             fprintf(stderr, "debug: removing pid %d\n", pid);
                                          */                                             */
   
                                         shutdown(client->fd, 2);                                          shutdown(client->fd, 2);
                                         close(client->fd);                                          close(client->fd);
Riadok 272  int main(int argc, char *argv[]) {
Riadok 212  int main(int argc, char *argv[]) {
                                         if (client_first != client) {                                          if (client_first != client) {
                                                 struct client* prev;                                                  struct client* prev;
                                                 for (prev = client_first;                                                  for (prev = client_first;
                                                                                                 prev->next != client;                                                                  prev->next != client;
                                                                                                 prev = prev->next )                                                                  prev = prev->next )
                                                         ;                                                          ;
   
                                                 prev->next = client->next;                                                  prev->next = client->next;
Legend:
Odstranené z verzie1.2  
zmenené riadky
  Pridané vo verzii1.3
Platon Group <platon@platon.sk> http://platon.sk/
Copyright © 2002-2006 Platon Group
Stránka používa redakčný systém Metafox 		Na začiatok