client.ec

中兴ZX10交换机接口代码

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<stdarg.h>
#include<string.h>
#include<errno.h>
#include<netdb.h>
#include<fcntl.h>
#include<sys/time.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include"skel.h"

#define CLIENT 1
#define SERVNAME "zxhlr"

extern int errno;

int sockfd=-1;
int port=5000;

/*************************************************************************************************/
main()
{
	char *remhost;
	int i;

	remhost=(char *)malloc(20);
	for(i=0;i<20;i++)
		remhost[i]='\0';
	strcpy(remhost,"zxhlr");

	if(net_open(remhost,SERVNAME,port)<0)
	{printf("the net_open error\n");
	return;}
	else{
		/*read and write by the description socket*/
		str_cli(stdin,sockfd);
		net_close();
	}
}
/*************************************************************************************************/
str_cli(fp,fd)
FILE *fp;
int fd;
{
	int n;
	char sendline[512],recvline[513];

    while(fgets(sendline,512,fp)!=NULL){
		n=strlen(sendline);
		if(writen(fd,sendline,n)!=n)
			printf("client:writen error\n");
		n=readline(fd,recvline,512);
		if(n<0)
			printf("client:n<0 error\n");
		recvline[n]=0;
		fputs(recvline,stdout);
	}
}
/*************************************************************************************************/
/*error handle*/
err_dump(errstr)
   char *errstr;
{
	printf("%s\n",errstr);
	exit(1);
}
/*************************************************************************************************/
/*read"n" bytes from a description*/
int
readn(fd,ptr,nbytes)
  register int fd;
  register char *ptr;
  register int nbytes;
  {
	  int nleft,nread;
	  nleft=nbytes;
	  while(nleft>0){
		  nread=read(fd,ptr,nleft);
		  if(nread<0)
			  return(nread);
		  else if(nread==0)
			  break;
		  nleft-=nread;
		  ptr+=nread;
	  }
	  return(nbytes-nleft);
  }
  /*************************************************************************************************/
  /*write "n" bytes to a descriptor*/
int 
writen(fd,ptr,nbytes)
register int fd;
register char *ptr;
register int nbytes;
{
	int nleft,nwritten;
	nleft=nbytes;
	while(nleft>0){
		nwritten=write(fd,ptr,nleft);
		if(nwritten<=0)
			return(nwritten);
		nleft-=nwritten;
		ptr+=nwritten;
	}
	return(nbytes-nleft);
}
/*************************************************************************************************/
/*read a line from a description*/
int 
readline(fd,ptr,maxlen)
register int fd;
register char *ptr;
register int maxlen;
{
	int n,rc;
	char c;

	for(n=1;n<maxlen;n++){
		if((rc=read(fd,&c,1))==1){
			*ptr++=c;
			if(c=='\n')
				break;
		}else if(rc==0){
			if(n==1)
				return(0);
			else
				break;
		}else
			return(-1);
	}
	*ptr=0;
	return(n);
}
/*************************************************************************************************/
#ifdef CLIENT

#ifndef INADDR_NONE
#define INADDR_NONE oxffffffff
#endif

struct sockaddr_in tcp_srv_addr;
struct servent tcp_serv_info;
struct hostent tcp_host_info;

/*open a TCP connect. only used by client */
int tcp_open(host,service,port)
char *host;
char *service;
int port;
{
	int fd,resvport;
	unsigned long inaddr;
	struct servent *sp;
	struct hostent *hp;
	bzero((char *)&tcp_srv_addr,sizeof(tcp_srv_addr));
	tcp_srv_addr.sin_family=AF_INET;

	if(strlen(service)!=0){
		if ((sp=getservbyname(service,"tcp"))==NULL){
			err_dump("tcp_open:unknown service");
			return(-1);
		}
		tcp_serv_info=*sp;
		if(port>0)
			tcp_srv_addr.sin_port=htons(port);
		else
			tcp_srv_addr.sin_port=sp->s_port;
	}else{
		if(port<0){
			err_dump("tcp_open:must specify either service or port");
			return(-1);
		}
		tcp_srv_addr.sin_port=htons(port);
	}
	if((inaddr=inet_addr(host))!=INADDR_NONE){
		bcopy((char *)&inaddr,(char *)&tcp_srv_addr.sin_addr,sizeof(inaddr));
		tcp_host_info.h_name=NULL;
	}else{
		if((hp=gethostbyname(host))==NULL){
			err_dump("tcp_open:host name error");
			return(-1);
		}
		tcp_host_info=*hp;
		bcopy(hp->h_addr,(char *)&tcp_srv_addr.sin_addr,hp->h_length);
	}
	if(port>=0){
		if((fd=socket(AF_INET,SOCK_STREAM,0))<0){
			err_dump("tcp_open:can't creat TCP socket");
			return(-1);
		}
	}else if (port<0){
		resvport=IPPORT_RESERVED-1;
		if((fd=rresvport(&resvport))<0){
			err_dump("tcp_open:can't get a reserved TCP port");
			return(-1);
		}
	}
	if(connect(fd,(struct sockaddr *)&tcp_srv_addr,sizeof(tcp_srv_addr))<0){
		err_dump("tcp_open:can't connect to server");
		close(fd);
		return(-1);
	}
	return(fd);
}
/*************************************************************************************************/
int net_open(host,service,port)
char *host;
char *service;
int port;
{
	if((sockfd=tcp_open(host,service,port))<0)
		return(-1);
	return(0);
}
/*************************************************************************************************/
#endif    /*client*/
net_close()
{
	close(sockfd);
	sockfd=-1;
}