What is wrong here?????

["Hossain, Mohammad" <m_hossain@xxxxxxxxxxxx>]

Hello,
    Thanks for your valuable time. I appreciate.

    Here is one IPv4 raw client and server code. When I run them, I get
nothing in the server. Would you pls help me out, what is wrong here???
    This code will compile without warning. I will wait for your reply.

    Arif.
/*   -------------------------- client code  ------------------------------
*/
 
/ * solaris compile : >gcc -D_XPG4_2 -o clt raw4Client.c -lnsl -lsocket
  * run     : >sudo ./clt
  */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define SERVERPORT 9000    /* the port users will be connecting to */

int main(int argc, char *argv[])
{
   int sockfd;
   struct sockaddr_in server_addr; 
        struct sockaddr_in client_addr;
   struct hostent *he;
   int nbytes;
        int i=0;
        int SOCK_OPT_ENABLE;
        char *buf ="Hello There .... \0";

   struct iovec io[1];
   struct msghdr msg;
   
   struct msghdr msgRecv;
   struct iovec ioRecv[1]; 
   char recvBuf[100];
   
        SOCK_OPT_ENABLE = 1;

        if (argc != 2)
      he=gethostbyname("nsdla03.trillium.com");  
        else 
   {
           if ((he=gethostbyname(argv[1])) == NULL) 
      {
              perror("gethostbyname"); exit(1);
      }
        }

        if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1)
   {
      perror("socket");  exit(1);
   }
        
   /* reuseaddr sock opt */
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &SOCK_OPT_ENABLE, 
                        sizeof(SOCK_OPT_ENABLE));

   /* fill up client info */
   client_addr.sin_family=AF_INET;
        client_addr.sin_port=htons(9001);
        client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        bzero(&(client_addr.sin_zero),8);
   
  /* No need to bind client raw socket  */   

   /* fill up server address info */
   server_addr.sin_family = AF_INET;     
   server_addr.sin_port = htons(SERVERPORT);
   server_addr.sin_addr = *((struct in_addr *)he->h_addr);
   bzero(&(server_addr.sin_zero),8);

   /* fill up sending msghdr structure */
   memset(&msg, 0, sizeof(struct msghdr));
   io[0].iov_base = buf; 
   io[0].iov_len = strlen(buf);
   msg.msg_name = &server_addr; 
   msg.msg_namelen = sizeof(struct sockaddr);
   msg.msg_iov = io; 
   msg.msg_iovlen = 1;
   msg.msg_control = NULL; 
   msg.msg_controllen = 0; 
   msg.msg_flags = 0; 

   /* send 5 data packets */
        for(i=0; i < 5; i++)
   {
      nbytes = sendmsg(sockfd, &msg, 0);
      printf("%d bytes sent\n", nbytes);
   
      if(nbytes == -1) 
      { 
         perror("sendmsg()"); 
         printf("Error #: %d\n", errno);
         exit(1); 
      }
      
                sleep(1);       
   }
   close(sockfd);
   return 0;
} 

/*   -------------------------- server code  ------------------------------
*/
/*
 * solaris compile : >gcc -D_XPG4_2 -o svr raw4Server.c -lnsl -lsocket
 * solaris run     : >sudo ./svr
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define MYPORT 9000   /* port doesn't mean anything in raw socket! */ 

int main(void)
{
  int sockfd;
  struct sockaddr_in server_addr; 
  struct sockaddr_in client_addr;
  int nbytes = 0;       

  struct msghdr msgRecv;
  struct iovec recvIovec[1]; 
  char buf[100];

  /* create the UDP socket */
  if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1) {
        perror("socket");
        exit(1);
   }

        /* bind the UDP socket of server with local port */
   memset(&server_addr, 0, sizeof(struct sockaddr_in));
        server_addr.sin_family=AF_INET;
        server_addr.sin_port=htons(MYPORT);
        server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        bzero(&(server_addr.sin_zero),8);
  
   /* binding */
   /* No Need to Bind RAW server !! */
   
        printf("\n            raw server waiting for data.....\n"); 
   
   while(1)
   {
      /* fill up receiving msghdr structure */
      memset(&msgRecv, 0, sizeof(struct msghdr));
      recvIovec[0].iov_base = buf;
      recvIovec[0].iov_len = strlen(buf);
   
      msgRecv.msg_name = &client_addr;
      msgRecv.msg_namelen = sizeof(client_addr); 
      msgRecv.msg_iov = recvIovec;
      msgRecv.msg_iovlen = 1;
      msgRecv.msg_control = NULL;
      msgRecv.msg_controllen = 0; 
      msgRecv.msg_flags = 0;
      
      /* receive data */
                if(nbytes = recvmsg(sockfd, &msgRecv, 0) == -1)
                {
                        perror("recvmsg");
         printf("Error #: %d\n", errno);
                        exit(1);
                }
      
      /* print recvd data info*/
      printf("received = %  bytes\n", nbytes);
      printf("%s\n", (char *)recvIovec[0].iov_base);
   
      nbytes = 0;
        }
   close(sockfd);

   return 0;
}