초보 socket 프로 그래 밍 입문 상세 안내

int recv(int s,void *buf,int len,unsigned int flags); 
int send(int s,const void * msg,int len,unsigned int falgs);

//        and socket     
#include <stdio.h> //
#include <stdlib.h> //
#include <errno.h> //errno      
#include <unistd.h> //
#include <stddef.h> //

#include <sys/socket.h> //  socket API
#include <sys/un.h> // 
#include <sys/types.h> //socket API         
#include <arpa/inet.h> //      
#include <netinet/in.h> //     （ ）、       

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <pthread.h>

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
 struct sockaddr_in servaddr;
 char buf[MAXLINE];
 int sockfd, n;
 sockfd = Socket(AF_INET, SOCK_STREAM, 0);
 bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 inet_pton(AF_INET, "192.168.191.6", &servaddr.sin_addr);
 servaddr.sin_port = htons(SERV_PORT);
 Connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
 while (fgets(buf, MAXLINE, stdin) != NULL) {
 Write(sockfd, buf, strlen(buf));
 n = Read(sockfd, buf, MAXLINE);
 if (n == 0)
 printf("the other side has been closed.
");
 else
 Write(STDOUT_FILENO, buf, n);
 }
 Close(sockfd);
 return 0;
}

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(void)
{
 struct sockaddr_in servaddr, cliaddr;
 socklen_t cliaddr_len;
 int listenfd, connfd;
 char buf[MAXLINE];
 char str[INET_ADDRSTRLEN];
 int i, n;

 listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 servaddr.sin_addr.s_addr = inet_addr("192.168.191.6");
 servaddr.sin_port = htons(SERV_PORT);

 Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
 Listen(listenfd, 20);
 printf("Accepting connections ...
");

 while (1) {
 cliaddr_len = sizeof(cliaddr);
 connfd = Accept(listenfd,
 (struct sockaddr *) &cliaddr,
 &cliaddr_len);
 while (1) {
 n = Read(connfd, buf, MAXLINE);
 if (n == 0) {
 printf("the other side has been closed.
");
 break;
 }
 printf("received from %s at PORT %d
",
 (char *)inet_ntop(AF_INET,
 &cliaddr.sin_addr, str,
 sizeof(str)),
 (int)ntohs(cliaddr.sin_port));
 for (i = 0; i < n; i++)
 buf[i] = toupper(buf[i]);
 Write(connfd, buf, n);
 }
 Close(connfd);
 }
}

hhc@my:~/sharefile/socket/tcp$ ./server &
[1] 15371
hhc@my:~/sharefile/socket/tcp$ Accepting connections ...
hhc@my:~/sharefile/socket/tcp$ ./client
this is a test! 
received from 192.168.191.6 at PORT 53685
THIS IS A TEST!

#include "wrap.h"

void perr_exit(const char *s)
{
 perror(s);
 exit(1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t * salenptr)
{
 int n;
 again:
 if ((n = accept(fd, sa, salenptr)) < 0) {
 if ((errno == ECONNABORTED) || (errno == EINTR))
 goto again;
 else
 perr_exit("accept error");
 }
 return n;
}

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (bind(fd, sa, salen) < 0)
 perr_exit("bind error");
}

void Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (connect(fd, sa, salen) < 0)
 perr_exit("connect error");
}

void Listen(int fd, int backlog)
{
 if (listen(fd, backlog) < 0)
 perr_exit("listen error");
}

int Socket(int family, int type, int protocol)
{
 int n;
 if ((n = socket(family, type, protocol)) < 0)
 perr_exit("socket error");
 return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
 ssize_t n;
 again:
 if ((n = read(fd, ptr, nbytes)) == -1) {
 if (errno == EINTR)
 goto again;
 else
 return -1;
 }
 return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
 ssize_t n;
 again:
 if ((n = write(fd, ptr, nbytes)) == -1) {
 if (errno == EINTR)
 goto again;
 else
 return -1;
 }
 return n;
}

void Close(int fd)
{
 if (close(fd) == -1)
 perr_exit("close error");
}

ssize_t Readn(int fd, void *vptr, size_t n)
{
 size_t nleft;
 ssize_t nread;
 char *ptr;
 ptr = vptr;
 nleft = n;
 while (nleft > 0) {
 if ((nread = read(fd, ptr, nleft)) < 0) {
 if (errno == EINTR)
 nread = 0;
 else
 return -1;
 } else if (nread == 0)
 break;
 nleft -= nread;
 ptr += nread;
 }
 return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
 size_t nleft;
 ssize_t nwritten;
 const char *ptr;
 ptr = vptr;
 nleft = n;
 while (nleft > 0) {
 if ((nwritten = write(fd, ptr, nleft)) <= 0) {
 if (nwritten < 0 && errno == EINTR)
 nwritten = 0;
 else
 return -1;
 }
 nleft -= nwritten;
 ptr += nwritten;
 }
 return n;
}

ssize_t my_read(int fd, char *ptr)
{
 static int read_cnt;
 static char *read_ptr;
 static char read_buf[100];
 if (read_cnt <= 0) {
 again:
 if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
 if (errno == EINTR)
 goto again;
 return -1;
 } else if (read_cnt == 0)
 return 0;
 read_ptr = read_buf;
 }
 read_cnt--;
 *ptr = *read_ptr++;
 return 1;
}

ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
 ssize_t n, rc;
 char c, *ptr;
 ptr = vptr;
 for (n = (ssize_t)1; n < (ssize_t)maxlen; n++) {
 if ((rc = my_read(fd, &c)) == 1) {
 *ptr++ = c;
 if (c == '
')
 break;
 } else if (rc == 0) {
 *ptr = 0;
 return n - 1;
 } else
 return -1;
 }
 *ptr = 0;
 return n;
}