Hi Hope you guys could help me with this.

We were given this assignment that implements the "Hello World" CS but I'm having problem with my compiler. Obviously the given program exercise was written in old C running in linux operating system. That's why once compiled using Windows it does't work. Some headers are not recognized.

I need to help on appropriate headers given in the program which are compatible to windows operating system.

Thanks. Here's the program:

/*The Hello World Server Program in C */
#include <stdio.h>
#include <stdlib.h>               /* exit() */
#include <string.h>              /* memset(), memcpy() */
#include <sys/utsname.h>         /* uname() */
#include <sys/types.h>
#include <sys/socket.h>          /* socket(), bind(), listen(), accept() */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd/in.h>           /*fork(), write(), close() */

 /*
  * prototypes
  */
int _GetHostName(char *buffer, int length);

 /*
  * constants
  */
  
const char MESSAGE[]="Hello, World!\n";
const int BACK_LOG=5;

int main(int argc,char *argv[]) {
    int serverSocket=0, on=0, port=0, status=0, childPid=0;
    struct hostent *hostPtr=NULL;
    char hostname[80]="";
    struct sockaddr_in serverName={0};
    
    if(2!=argc){
                fprintf(stderr, "Usage: %s <port>\n", argv[0]);
                exit(1);
                }
                port=atoi(argv[1]);
                serverSocket=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
                if (-1==serverSocket){
                                      perror("socket()");
                                      exit(1);
                                      }
                                      
/*
* turn off bind address checking, and allow port numbers
* to be reused - otherwise the TIME_WAIT phenomenon will
* prevent binding to these address.port combinations for
* (2 *MSL) seconds.
*/

on=1;
status=setsockopt(serverSocket, SOL_SOCKET,SO_REUSEADDR,
                                (const char*)&on,sizeof(on));
if(-1==status){
               perror("setsockopt(...,SO_REUSEADDR,...)");
               }
               
/*
* when connection is closed, there is a need to linger to ensure
* all data is transmitted, so turn this on also
*/
{
      struct linger linger={0};
      linger.1_onoff=1;
      linger.1_linger=30;
      status=setsockopt(serverSocket, SOL_SOCKET,SO_LINGER,
                                      (const char*)&linger,sizeof(linger));
                                      if(-1==status){
                                                     perror("setsockopt(...,SO_LINGER,...)");
                                                     }
      }
}

/*
* find out who I am
*/

status=_GetHostName(hostname,sizeof(hostname));
if(-1==status){
               perror("_GetHostName()");
               exit(1);
               }
hostPtr=gethostbyname(hostname);
if (NULL==hostPtr){
                   perror("gethostbyname()");
                   exit(1);
                   }

(void)memset(&serverName,0,sizeof(serverName));
(void)memcpy(&serverName.sin_addr,hostPtr->h_addr,hostPtr->h_length);

/*
* to allow server be contactable on any of its
* IP addresses, uncomment the following line of code:
*
* serverName.sin_addr.s_addr = hton1(INADDR_ANY);
*/

serverName.sin_family=AF_INET;
serverName.sin_port=htons(port);                 /* network-order */

status=bind(serverSocket,(struct sockaddr*)&serverName,sizeof(serverName));
if(-1==status){
               perror("bind()");
               exit(1);
               }
               
status=listen(serverSocket,BACK_LOG);
if(-1==status){
               perror("listen()");
               exit(1);
               }
               
               for(;;){
                       struct sockaddr_in clientName={0};
                       int slaveSocket, clientLength=sizeof(clientName);
                       
                       (void)memset(&clientName,0,sizeof(clientName));
                       
                       slaveSocket=accept(serverSocket,
                       (struct sockaddr*)&clientName,&clientLength);
                       if(-1==slaveSocket){
                                           perror("accept()");
                                           exit(1);
                                           }
                                           
                                           childPid=fork();
                                           
                                           switch(childPid){
                       case -1:/* ERROR */
                            perror("fork()");
                            exit(1);
                       case 0:/* child process */
                            close(serverSocket);
                            if(-1==getpeername(slaveSocket,
                                                           (struct sockaddr*)&clientName,&clientLength)){
                                                                   perror("getpeername()");
                                                                   }else{
                                                                         printf("Connection request from %s\n",
                                                                         inet_ntoa(clientName.sin_addr));
                                                                         }
                       /* Server application specific code goes here,
                        *
                        * e.g. perform some action, respond to client etc.
                       */
                       write(slaveSocket,MESSAGE,strlen(MESSAGE));
                       close(slaveSocket);
                       exit(0);
               default:/* parent process */
                          close(slaveSocket);
                          }
                          }
                          
               return 0;
               }
               
               /*
                * Local replacement of gethostname() to aid portability
               */
               int _GetHostName(char *buffer,int length){
                   struct utsname sysname={0};
                   int status=0;
                   
                   status=uname(&sysname);
                   if(-1!=status){
                                  strncpy(buffer,sysname.nodename,length);}
                                  return(status);
                                  }


/*The Hello World Client Program in C */
#include <stdio.h>               /* perror() */
#include <stdlib.h>              /* atoi() */
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd/in.h>           /* read() */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

int main(int argc,char *argv[]) {
    int clientSocket,remotePort,status=0;
    struct hostent *hostPtr=NULL;
    struct sockaddr_in serverName={0};
    char buffer[256]="";
    char *remoteHost=NULL;
    
    if(3!=argc){
                fprintf(stderr, "Usage: %s <serverHost> <serverPort>\n", argv[0]);
                exit(1);
                }
                remoteHost=argv[1];
                remotePort=atoi(argv[2]);
                client$Socket=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
                if (-1==serverSocket){
                                      perror("socket()");
                                      exit(1);
                                      }
                                      
/*
 * need to resolve the remote sever name or IP address
 */

hostPtr=gethostbyname(remoteHost);
if(NULL==hostPtr){
                   hostPtr=gethostbyaddr(remoteHost,strlen(remoteHost)AF_INET);
                   if(NULL==hostPtr){
                   perror("Error resolving server address");
                   exit(1);
                   }
}
serverName.sin_family=AF_INET;
serverName.sin_port=htons(remotePort);
(void)memcpy(&serverName.sin_addr,hostPtr->h_addr,hostPtr->h_length);
status=connect(clientSocket,(struct sockaddr*)&serverName,sizeof(serverName));
if(-1==status){
               perror("connect()");
               exit(1);
               }
               
/*
 * Client application specific code goes here,
 *
 * e.g. receive messages from server, respond, etc.
 */
while(0<(status=read(clientSocket,buffer,sizeof(buffer)-1)));
printf("%d: %s",status,buffer);
if(-1!=status)perror("read()");
close(clientSocket);
return 0;
}

I don't suppose it crossed your mind to pay attention to the half dozen or so places where it tells you to use code tags.
Nope, didn't think so.

This article has been dead for over six months. Start a new discussion instead.