int main(int argc,char* argv[])
{
int serv_sock;
int mesg_len;
struct sockaddr_in serv_addr,clnt_addr;
socklen_t clnt_addr_size;
char message[BUF_SIZE];
if(argc!=2)
{
printf("Usage:%s <port>\n",argv[0]);
return 0;
}
memset(message,0,sizeof(message));
serv_sock=socket(PF_INET,SOCK_DGRAM,0);
if(serv_sock==-1)
error_handling("socket() error");
memset(&serv_addr,0,sizeof(&serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(atoi(argv[1]));
clnt_addr_size=sizeof(clnt_addr);
if(bind(serv_sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr))==-1)
error_handling("bind() error");
int i;
for(i=0;i<3;i++)
{
sleep(10);
mesg_len=recvfrom(serv_sock,message,sizeof(message),0,(struct sockaddr*)&clnt_addr,&clnt_addr_size);
printf("message from client %s\n",message);
//sendto(serv_sock,message,mesg_len,0,(struct sockaddr*)&clnt_addr,clnt_addr_size);
}
close(serv_sock);
return 0;
}
int main(int argc, char *argv[]){
int serv_sd, clnt_sd; //서버의 소켓, 데이터 교환에 이용활 accept후 생성되는 소켓 정보를 담을 변수 선언
char buf[BUF_SIZE]; //데이터를 담을 버퍼를 선언
int read_cnt; //데이터에서 보내고 읽은수를 저장할 변수 선언
struct sockaddr_in serv_adr; //각 소켓에 대한 주소 정보를 담을 변수 선언
struct sockaddr_in clnt_adr;
socklen_t clnt_adr_sz; //clnt_adr의 크기를 저장할 변수 선언
FILE * fp; //보낼 파일을 읽기 위한 파일 포인터 변수 선언
if(argc!=2){ //해당 포트에서 잘 연결이 되었는지 확인하는 하수
printf("Usage : %s <port>\n",argv[0]);
exit(1);
}
fp = fopen("lec11.pdf","rb"); //lec11.pdf의 파일을 전송하기 위해, 파일 포인터로 바이너리 형태로 읽어 온다.
serv_sd = socket( PF_INET, SOCK_STREAM, 0 ); //IPv4형식의 프로토콜이고, tcp 스트림 통신을 위한 소켓을 생성
if(serv_sd==-1) //소켓 생성의 성공여부 확인을 위한 함수
error_handling("socket() error");
memset(&serv_adr,0,sizeof(serv_adr)); //주소 정보를 담을 구조체 변수 초기화
serv_adr.sin_family=AF_INET; //IPv4주소쳬계를 이용하기 때문에 설정
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); //소켓을 사용하는 컴퓨터의 ip주소 자동 할당
serv_adr.sin_port=htons(atoi(argv[1]));//해당하는 포트에 대한 정보 설정
if(bind(serv_sd,(struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error"); //포트와 소켓이 잘 연결 되었는지 확인
if(listen(serv_sd,5)==-1)//listen함수로 요청을 기다리고, 해당 요청의 성공여부 확인
error_handling("listen() error");
clnt_adr_sz=sizeof(clnt_adr); //clnt_adr 의 사이즈 설정
clnt_sd=accept(serv_sd,(struct sockaddr*)&clnt_adr,&clnt_adr_sz); //accept를 통해 요청상태의 클라이언트와 스트림 연결 생성
if(clnt_sd==-1) //스트림 연결의 성공여부 확인
error_handling("accept() error");
else
printf("Connected client 1 \n");
while(1)
{
read_cnt = fread((void*)buf,1,BUF_SIZE, fp); //파일 포인터르 이용하여 바이너리 데이터를 읽어옴
if( read_cnt < BUF_SIZE){ //보내는 단위가 buf 사이즈보다 작게 남아있으면 그만큼만 읽어들이고 브레이크로 빠져나옴
write(clnt_sd,buf,read_cnt);
break;
}
write(clnt_sd,buf,BUF_SIZE); //버퍼 사이즈만큼 데이터를 전송
}
shutdown(clnt_sd,SHUT_WR);//스트림 소켓의 저옵를 닫아줌(쓰는 소켓만 닫아주고, 읽는 소켓은 열어둠 -> 클라이언트의 마지막 메시지 확인을 위하여)
read(clnt_sd,buf,BUF_SIZE);//클라이언트에서 보내는 확인 메시지 확인
printf("Message from client:%s \n",buf);
fclose(fp); //파일 전송이 끝났으므로 , 파일 포인터를 닫아줌
close(clnt_sd);//스트림 소켓 닫아줌
close(serv_sd);//서버 소켓을 닫아줌
return 0;
}
int main(int argc,char* argv[])
{
int sd;
struct sockaddr_in serv_addr;
int read_cnt;
FILE * fp;
fp=fopen("receive.dat","wb");
char message[BUF_SIZE];
if(argc!=3)
{
printf("Usage:%s<IP> <port>\n",argv[0]);
return 0;
}
sd=socket(PF_INET,SOCK_STREAM,0);
if(sd==-1)
error_handling("socket() error");
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
serv_addr.sin_port=htons(atoi(argv[2]));
if(connect(sd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))==-1)
error_handling("connect() error");
while(read_cnt=read(sd,message,BUF_SIZE)!=0) //read success return 1!!
{
//printf("read_cnt %d,strlrn(message) %lu",read_cnt,(unsigned long int)strlen(message));
fwrite((void *)message,1,strlen(message)-1,fp);
//printf("%s\n",message);
memset(message,0,BUF_SIZE);
}
puts("received file data");
write(sd,"thank you ",10);
fclose(fp);
close(sd);
return 0;
}
int main(int argc,char **argv){
int serv_sock;
struct sockaddr_in serv_addr,clnt_addr;
socklen_t clnt_addr_size;
int str_len;
char message[BUF_SIZE];
if(argc!=2){
printf("Usage : %s <PORT> \n",argv[0]);
exit(1);
}
serv_sock=socket(PF_INET,SOCK_DGRAM,0);
if(serv_sock==-1) error_handling("UDP Server socket error");
memset(&serv_addr,0,sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(atoi(argv[1]));
serv_addr.sin_addr.s_addr=inet_addr("127.0.0.1");
if(bind(serv_sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr))==-1)
error_handling("UDP Server bind error");
while(1){
clnt_addr_size=sizeof(clnt_addr);
str_len=recvfrom(serv_sock,message,BUF_SIZE,0,(struct sockaddr*)&clnt_addr,&clnt_addr_size);
sendto(serv_sock,message,str_len,0,(struct sockaddr*)&clnt_addr,clnt_addr_size);
}
close(serv_sock);
return 0;
}
int main(int argc, char const *argv[])
{
int send_sock;
struct sockaddr_in broad_adr;
FILE *fp;
char buf[BUF_SIZE];
int so_brd = 1;
if (argc != 3)
{
printf("Usage : %s <GroupIP> <port>\n", argv[0]);
exit(1);
}
send_sock = socket(PF_INET, SOCK_DGRAM, 0);
memset(&broad_adr, 0, sizeof(broad_adr));
broad_adr.sin_family = AF_INET;
if(!inet_aton(argv[1], &broad_adr.sin_addr))
error_handling("convertion error"); // multicast IP
broad_adr.sin_port = htons(atoi(argv[2])); //multicast Port
setsockopt(send_sock, SOL_SOCKET, SO_BROADCAST, (void*)&so_brd, sizeof(so_brd));
if((fp = fopen("news.txt","r")) == NULL)
error_handling("open file error");
while(!feof(fp))
{
fgets(buf, BUF_SIZE, fp);
sendto(send_sock, buf, strlen(buf), 0, (struct sockaddr*)&broad_adr, sizeof(broad_adr));
sleep(2);
}
fclose(fp);
close(send_sock);
return 0;
}
int main(int argc, char *argv[]){
int sock;
pid_t pid;
char message[BUF_SIZE];
struct sockaddr_in serv_addr;
if(argc != 3){
printf("Usage : %s <ip> <port>\n", argv[0]);
exit(1);
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == -1)
error_handling("socket() error");
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
serv_addr.sin_port = htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1)
error_handling("connect() error");
else
puts("Connected ........");
pid = fork();
if(pid == 0)
write_routine(sock, message);
else
read_routine(sock, message);
close(sock);
return 0;
}
void receive_ip_url() {
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
int clnt_adr_sz;
int option = 1;
int size;
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(5959);
if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr)) == -1)
error_handling("bind() error");
if(listen(serv_sock, 5) == -1)
error_handling("listen() error");
setsockopt( serv_sock, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option) );
clnt_adr_sz = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
strncpy(clnt_IP, inet_ntoa(clnt_adr.sin_addr), strlen(inet_ntoa(clnt_adr.sin_addr)));
printf("\nKey Generation Request from IP : %s\n", clnt_IP);
read(clnt_sock, URL, sizeof(URL)); // 들어오는 URL과 IP를 URL에 받는다.
IP = strtok(URL, "^");
IP = strtok(NULL, "^");
printf("Received URL, IP : %s, %s\n\n", URL, IP);
close(serv_sock);
close(clnt_sock);
// printf("IP/URL Receiver socket closed\n");
}
int main(int argc, char* argv[]) {
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
socklen_t clnt_adr_size;
char buf[BUF_SIZE];
pthread_t t_id;
if (argc != 2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("bind() error");
if (listen(serv_sock, 20) == -1)
error_handling("listen() error");
while (1) {
clnt_adr_size = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_sock, &clnt_adr_size);
printf("Connection Request : %s:%d\n", inet_ntoa(clnt_adr.sin_addr), ntohs(clnt_adr.sin_port));
pthread_create(&t_id, NULL, request_handler, &clnt_sock);
pthread_detach(t_id);
}
close(serv_sock);
return 0;
}
int main(int argc, char *argv[])
{
FILE *fp_read, *fp_write;
char buff[BUFF_SIZE];
if(3 != argc){
printf("Usage : %s <oldfile> <newfile>\n", argv[0]);
exit(1);
}
fp_read = fopen(argv[1], "r");
if(NULL == fp_read){
error_handling("fopen() file for reading error!");
}
fp_write = fopen(argv[2], "w");
if(NULL == fp_write){
error_handling("fopen() file for writing error!");
}
while(fgets(buff, BUFF_SIZE, fp_read) != NULL){
fputs(buff, fp_write);
}
/*
while((ch=getc(fp))!=EOF)
putc(ch, stdout);//putchar(ch);
//int fputc(int ch, FILE *fp); putc() === fputc
*/
fclose(fp_read);
fclose(fp_write);
return 0;
}
int main(int argc, char* argv[])
{
int sock;
struct sockaddr_in serv_addr;
char message[BUF_SIZE];
int str_len;
int recv_len, recv_cnt;
if (argc != 3)
{
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
{
error_handling("socket() error");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
serv_addr.sin_port= htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)
{
error_handling("connect() error!");
}
else
{
puts("Connected Success!!!");
}
while (1)
{
fputs("Input message(Q to quit): ", stdout);
fgets(message, BUF_SIZE, stdin);
if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
break;
str_len = write(sock, message, strlen(message));
recv_len = 0;
while(recv_len < str_len)
{
recv_cnt = read(sock, &message[recv_len], BUF_SIZE - 1);
if (recv_cnt == -1)
{
error_handling("read() error!");
}
recv_len += recv_cnt;
}
message[recv_len] = 0;
printf("Message from server : %s \n", message);
}
close(sock);
return 0;
}
int command_cd(int sockfd, t_data *data)
{
char old_path[PATH_MAX];
char *tmp;
char *new_path;
int ret;
tmp = get_char_string(sockfd);
getcwd(old_path, PATH_MAX);
new_path = ft_strijoin(3, old_path, "/", tmp);
free(tmp);
if (chdir(new_path) == -1)
{
free(new_path);
return (error_handling(-1, sockfd, MSG_NO_SUCH_FILE));
}
tmp = getcwd(NULL, PATH_MAX);
if (ft_strncmp(data->root_path, tmp, ft_strlen(data->root_path)) != 0)
{
chdir(old_path);
ret = error_handling(-1, sockfd, MSG_CD_ACCESS_DENIED);
}
else
ret = error_handling(0, sockfd, MSG_CD_OK);
free(tmp);
free(new_path);
return (ret);
}
int main(int argc, char *argv[])
{
int sock_client;
struct sockaddr_in recv_addr;
if(3 != argc){
printf("Usage : %s <IP> <Port>\n", argv[0]);
exit(EXIT_FAILURE);
}
memset(&recv_addr, 0, sizeof(recv_addr));
recv_addr.sin_family = AF_INET;
recv_addr.sin_addr.s_addr = inet_addr(argv[1]);
recv_addr.sin_port = htons(atoi(argv[2]));
sock_client = socket(PF_INET, SOCK_STREAM, 0);
if(sock_client < 0){ // == -1
error_handling("Error socket()");
}
if(-1 == connect(sock_client, (struct sockaddr*)&recv_addr, sizeof(recv_addr))){
error_handling("Error connect()");
}
write(sock_client, "123", strlen("123"));
send(sock_client, "45", strlen("45"), MSG_OOB);
send(sock_client,"9", strlen("9"), MSG_OOB);
write(sock_client, "Hello", sizeof("Hello"));
send(sock_client,"0", strlen("0"), MSG_OOB);
write(sock_client, "789", strlen("789"));
send(sock_client, "456", strlen("456"), MSG_OOB);
//似乎只有最后一个MSG_OOB被作为Urgent接收1Byte
close(sock_client);
return 0;
}
int main(int argc, char *argv[]) {
int sock;
struct sockaddr_in serv_addr;
char message[30];
int str_len;
if (argc != 3) {
printf("Usage: %s <IP> <port>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1) {
error_handling("sock() error!");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
serv_addr.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
error_handling("connect() error!");
}
str_len = read(sock, message, sizeof(message)-1);
if (str_len == -1) {
error_handling("read() error!");
}
printf("Message from server: %s \n", message);
close(sock);
return 0;
}
/*
* TCP server functions
*
* all process socket(), bind(), and listen()
* with string of port NO. and count of listen socket
* returns socket fd
*/
int tcp_server_listen(int port, int num)
{
int ret;
int sock;
struct sockaddr_in serv_addr;
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
return error_handling("socket()");
memset(&serv_addr, 0, sizeof(struct sockaddr_in));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(port);
ret = bind(sock, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr_in));
if (ret == -1)
return error_handling("bind()");
ret = listen(sock, num);
if (ret == -1)
return error_handling("listen()");
return sock;
}
int main(int argc, char *argv[]){
int sock;
int snd_buf=1024*3, rcv_buf=1024*3, state;
socklen_t len;
sock=socket(AF_INET, SOCK_STREAM, 0);
state=setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&rcv_buf, sizeof(rcv_buf));
if(state)
error_handling("setsockopt... error");
state=setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&snd_buf, sizeof(snd_buf));
if(state)
error_handling("setsockopt... error");
len=sizeof(snd_buf);
state=getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&snd_buf, &len);
if(state)
error_handling("getsockopt... error");
len=sizeof(rcv_buf);
state=getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&rcv_buf, &len);
if(state)
error_handling("getsockopt... error");
printf("Input buffer size: %d \n", rcv_buf);
printf("Output buffer size: %d \n", snd_buf);
return 0;
}
int main(int argc, char *argv[])
{
int serv_sock;
char message[BUF_SIZE];
int str_len;
socklen_t clnt_adr_sz;
struct sockaddr_in serv_adr, clnt_adr;
if(argc != 2) {
printf("Usage: %s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_DGRAM, 0);
if(serv_sock == -1)
error_handling("UPD socket creation error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("bind() error");
while(1) {
clnt_adr_sz = sizeof(clnt_adr);
str_len = recvfrom(serv_sock, message, BUF_SIZE, 0, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
sendto(serv_sock, message, str_len, 0, (struct sockaddr *)&clnt_adr, clnt_adr_sz);
}
close(serv_sock);
return 0;
}
int main(int argc, char *argv[])
{
int sock_server;
int sock_client;
struct sockaddr_in addr_server;
struct sockaddr_in addr_client;
socklen_t size_addr_client;
pthread_t pthread_id;
if(argc!=2){ //命令行中启动服务程序仅限一个参数：端口号
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
pthread_mutex_init(&mutex, NULL);
//调用socket函数创建套接字
sock_server = socket(PF_INET, SOCK_STREAM, 0);
if(-1 == sock_server){
error_handling("socket() error.");
}
memset(&addr_server, 0, sizeof(addr_server));
addr_server.sin_family = AF_INET;
addr_server.sin_addr.s_addr = htonl(INADDR_ANY);
addr_server.sin_port = htons(atoi(argv[1]));
//调用bind函数分配IP地址和端口号
if( -1 == bind( sock_server, (struct sockaddr*)&addr_server,
sizeof(addr_server)) ){
error_handling("bind() error");
}
//监听端口的连接请求,连接请求等待队列size为5
if( -1 == listen(sock_server, 5) ){
error_handling("listen() error");
}
//
while(1){
size_addr_client = sizeof(addr_client);
sock_client = accept( sock_server, (struct sockaddr*)&addr_client, &size_addr_client);
pthread_mutex_lock(&mutex);
socks_client[count_client++] = sock_client;//Lock 访问公共代码区
pthread_mutex_unlock(&mutex);
pthread_create(&pthread_id, NULL, client_handler, (void *)&sock_client);
pthread_detach(pthread_id);//销毁线程
printf("Client IP:%s \n", inet_ntoa(addr_client.sin_addr));
}//end of while
//断开连接，关闭套接字
close(sock_server);
pthread_mutex_destroy(&mutex);
return 0;
}
int main(int argc, char* argv[])
{
int serv_sock;
int clnt_sock;
int str_len, i;
struct sockaddr_in serv_adr;
struct sockaddr_in clnt_adr;
socklen_t clnt_adr_sz;
FILE *readfp;
FILE *writefp;
char message[BUF_SIZE];
if(argc != 2)
{
printf("Usage: %s <port> \n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if(serv_sock == -1)
error_handling("socket() error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("bind() error");
if(listen(serv_sock, 5) == -1)
error_handling("listen() error");
clnt_adr_sz = sizeof(clnt_adr);
for(i = 0; i < 5; i++)
{
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
if(clnt_sock == -1)
error_handling("accpet() error");//?
else
printf("Cennected client %d \n", i + 1);
//改变内容
readfp = fdopen(clnt_sock, "r");
writefp = fdopen(clnt_sock, "w");
while(!feof(readfp))
{
fgets(message, BUF_SIZE, readfp);
fputs(message, writefp);
fflush(writefp);
}
fclose(readfp);
fclose(writefp);
}
close(serv_sock);
return 0;
}
int main(int argc, char *argv[]){
int serv_sd, clnt_sd;
struct sockaddr_in serv_adr;
struct sockaddr_in clnt_adr;
socklen_t clnt_adr_sz;
pthread_t t_id;
if(argc!=2){
printf("Usage : %s <port>\n",argv[0]);
exit(1);
}
//FILE * fp;
//fp = fopen("lec11.pdf","rb");
pthread_mutex_init(&mutx,NULL);
serv_sd = socket( PF_INET, SOCK_STREAM, 0 );
if(serv_sd==-1)
error_handling("socket() error");
memset(&serv_adr,0,sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); //소켓을 사용하는 컴퓨터의 ip주소 자동 할당
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sd,(struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sd,5)==-1)
error_handling("listen() error");
while(1)
{
clnt_adr_sz=sizeof(clnt_adr);
clnt_sd=accept(serv_sd,(struct sockaddr*)&clnt_adr,&clnt_adr_sz);
if(clnt_sd==-1)
error_handling("accept() error");
else
printf("Connected client %d \n",clnt_cnt+1);
pthread_mutex_lock(&mutx);
clnt_socks[clnt_cnt++] = clnt_sd;
pthread_mutex_unlock(&mutx);
pthread_create(&t_id, NULL, handle_clnt, (void*)&clnt_sd);
pthread_detach(t_id);
//printf("Connected client IP: %s\n",inet_ntoa(clnt_adr.sin_addr));
}
close(serv_sd);
return 0;
}
int main(int argc, char *argv[]){
int serv_sock, clnt_sock;
char message[BUF_SIZE];
int str_len, i;
struct sockaddr_in serv_addr, clnt_addr;
socklen_t clnt_adr_sz;
if(argc!=2){
printf("Usage:%s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if(serv_sock == -1)
error_handling("socket() error");
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
clnt_adr_sz=sizeof(clnt_addr);
for(i=0;i<5;i++){
clnt_sock=accept(serv_sock, (struct sockaddr*) &clnt_addr, &clnt_adr_sz);
if(clnt_sock==-1)
error_handling("accept() error");
else
printf("Connected client IP : %s, num : %d\n", inet_ntoa(clnt_addr.sin_addr),i+1);
int flag2=1;
while((str_len=read(clnt_sock, message,1))!=0){
printf("flag : %d, %s\n",flag2,message);
if((flag2==0)&&(message[0]=='1')){
printf("door open! %d\n",flag2);
flag2=1;
system("./pushServer");
}
else if((flag2==1)&&(message[0]=='0')){
printf("door close%d\n",flag2);
flag2=0;
}
}
close(clnt_sock);
}
close(serv_sock);
return 0;
}
int main ( int argc, char * argv[] ) {
int sock;
struct sockaddr_in serv_adr;
char buf [ BUF_SIZE - 5 ];
char msg [ BUF_SIZE ];
int msg_len, str_len, i;
if ( argc != 3 ) {
printf ( "Usage: %s <IP> <Port> \n", argv[0] );
exit ( 1 );
}
sock = socket ( PF_INET, SOCK_STREAM, 0 );
if ( sock == -1 )
error_handling ( "socket() error" );
memset ( &serv_adr, 0, sizeof ( serv_adr ) );
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = inet_addr ( argv[1] );
serv_adr.sin_port = htons ( atoi ( argv[2] ) );
if ( connect ( sock, ( struct sockaddr* ) &serv_adr, sizeof ( serv_adr ) ) == -1 )
error_handling ( "connect() error" );
while ( 1 ) {
fputs ( "input message(Quit: q): ", stdout );
fgets ( buf, sizeof ( buf ), stdin );
if ( !strcmp ( buf, "q\n" ) || !strcmp ( buf, "Q\n" ) )
break;
str_len = strlen ( buf ) - 1;
msg[0] = ( char ) str_len;
&msg[4] = buf;
write ( sock, msg, BUF_SIZE );
}
close ( sock );
return 0;
}
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock, i;
struct sockaddr_in serv_adr, clnt_adr;
int clnt_adr_sz;
pthread_t t_id;
if(argc!=2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
pthread_mutex_init(&mutx, NULL);
serv_sock=socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
while(1)
{
clnt_adr_sz=sizeof(clnt_adr);
clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz);
if(clnt_cnt >= MAX_CLNT) {
printf("CONNECT FAIL : %d \n", clnt_sock);
write(clnt_sock, "too many users. sorry", BUF_SIZE);
continue;
}
pthread_mutex_lock(&mutx);
clnt_socks[clnt_cnt]=clnt_sock;
read(clnt_sock, clnt_name, NAME_SIZE);
strcpy(clnt_names[clnt_cnt++], clnt_name);
// ㄴ 클라이언트로부터 받은 접속자 이름입력
pthread_mutex_unlock(&mutx);
pthread_create(&t_id, NULL, handle_clnt, (void*)&clnt_sock);
pthread_detach(t_id);
printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
}
close(serv_sock);
return 0;
}
int main(int argc, char *argv[])
{
int serv_sock;
int clnt_sock;
struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size;
char message[] = "hello world";
if (argc != 2)
{
printf("Usage :%s <port>\n", argv[0]);
exit(1);
}
// 1.调用docket 套接字
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if (serv_sock == -1)
{
error_handling('socket() error');
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1]));
// 2. 使用bind 函数分配IP地址 和端口号
if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
{
error_handling('bind() error');
}
// 3 抵用listen 函数转为可接收请求转态
if (listen(serv_sock, 5) == -1)
{
error_handling('acept() error');
}
clnt_addr_size = sizeof(clnt_addr);
// 调用accept 函数接收请求连接
clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
if (clnt_sock == -1)
error_handling("accept() error");
write(clnt_sock, message, sizeof(message));
close(clnt_sock);
close(serv_sock);
return 0;
}
int main(int argc, const char *argv[])
{
int serv_sock, clnt_sock;
char opinfo[BUF_SIZE];
int result, opnd_cnt, i;
int recv_cnt, recv_len;
struct sockaddr_in serv_addr, clnt_addr;
socklen_t clnt_addr_sz;
if (argc != 2) {
printf("Usage: %s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if (serv_sock == -1) {
error_handling("socket() error!");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1]));
if (bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
error_handling("bind() error!");
}
if (listen(serv_sock, 5) == -1) {
error_handling("listen() error!");
}
clnt_addr_sz = sizeof(clnt_addr);
for (i = 0; i < 5; i++) {
opnd_cnt = 0;
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_sz);
read(clnt_sock, &opnd_cnt, 1);
recv_len = 0;
while ((opnd_cnt*OPSZ+1) > recv_len) {
recv_cnt = read(clnt_sock, &opinfo[recv_len], BUF_SIZE-1);
recv_len += recv_cnt;
}
result = calculate(opnd_cnt, (int*)opinfo, opinfo[recv_len-1]);
write(clnt_sock, (char*)&result, sizeof(result));
close(clnt_sock);
}
close(serv_sock);
return 0;
}
int main(int argc, char *argv[])
{
int sock_recv;
struct sockaddr_in addr_recv;
struct ip_mreq join_addr;
char buff[BUFF_SIZE];
// FILE *fp;
int str_len;
if(3 != argc){
printf("Usage : %s <GroupIP> <Port> \n", argv[0]);
exit(1);
}
sock_recv = socket(PF_INET, SOCK_DGRAM, 0);
if(-1 == sock_recv){
error_handling("socket() error!");
}
/*
fp = fopen("received.dat", "wb");
if(NULL == fp){
error_handling("File open failed!");
}
*/
memset(&addr_recv, 0, sizeof(addr_recv));
addr_recv.sin_family = AF_INET;
addr_recv.sin_addr.s_addr = htonl(INADDR_ANY);
addr_recv.sin_port = htons(atoi(argv[2]));
if(-1 == bind(sock_recv, (struct sockaddr*)&addr_recv, sizeof(addr_recv))) error_handling("Error bind()");
//设置加入多播组
join_addr.imr_multiaddr.s_addr = inet_addr(argv[1]); //Group IP
join_addr.imr_interface.s_addr= htonl(INADDR_ANY); //Host IP
setsockopt(sock_recv, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*)&join_addr, sizeof(join_addr));
//receive and display the multicast message
while(1){
str_len = recvfrom(sock_recv, buff, BUFF_SIZE-1, 0, NULL, 0);
if(str_len < 0) break;
buff[str_len] = 0;
fputs(buff, stdout);
}//Error:the last packet received twice! && The progress will not exit!
//fclose(fp);
puts("File Received from server is over!\n");
close(sock_recv);
return 0;
}
int main(int argc, char * argv[])
{
int sock;
char opmsg[BUF_SIZE];
int result,opnd_cnt, i;
struct sockaddr_in serv_adr;
if(argc!=3) {
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if(sock == -1)
error_handling("socket() error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
serv_adr.sin_port = htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr))==-1)
error_handling("connect() error");
else
printf("Connected............\n");
fputs("operand count: ", stdout);
scanf("%d", &opnd_cnt);
opmsg[0] = (char)opnd_cnt;
for(i=0; i<opnd_cnt; i++)
{
printf("Operand %d: ", i+1);
scanf("%d", (int*)&opmsg[i*OPSZ+1]); //fix i+OPSZ+1 -> i*OPSZ+1
}
fgetc(stdin);
fputs("Operator: ", stdout);
scanf("%c", &opmsg[opnd_cnt * OPSZ + 1]);
//debug
print_binaryc(opmsg, opnd_cnt * OPSZ + 1, sizeof(char));
write(sock, opmsg, opnd_cnt * OPSZ + 2);
read(sock, &result, RLT_SIZE);
printf("Operation result: %d \n", result);
close(sock);
return 0;
}
int main(int argc, char *argv[])
{
int serv_sock;
int clnt_sock;
int i;
struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size;
char message[15]={ "Hello World!" };
if(argc!=2){
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock=socket(PF_INET, SOCK_STREAM, 0);// 소켓을 생성한다.
if(serv_sock == -1)
error_handling("socket() error");
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(atoi(argv[1]));
if(message[14] < '9') (int)message[14]++;
else {
(int)message[13]++;
message[14] = '0';
}
if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1 )
error_handling("bind() error"); //IP주소와 포트번호를 할당하고 있다.
for(i=0; i<30; i++) {
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");//listen 함수를 호출하고 있다. 연결요청 대기 상태가 된다
clnt_addr_size=sizeof(clnt_addr);
clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size);
if(clnt_sock==-1)
error_handling("accept() error");
write(clnt_sock, message, sizeof(message));
}
close(clnt_sock);
close(serv_sock);
return 0;
}
int main(int argc, char *argv[])
{
int serverSocket;
int clientSocket;
struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size;
char message[]="Hello World!";
if (argc != 2)
{
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serverSocket = socket(PF_INET, SOCK_STREAM, 0);
if (serverSocket == -1)
{
error_handling("socket() error");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1]));
if (bind(serverSocket, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1)
{
error_handling("bind() error");
}
if (listen(serverSocket, 5) == -1)
{
error_handling("listen() error");
}
clnt_addr_size = sizeof(clnt_addr);
clientSocket = accept(serverSocket, (struct sockaddr*)&clnt_addr, &clnt_addr_size);
if (clientSocket == -1)
{
error_handling("accept() error");
}
write(clientSocket, message, sizeof(message));
close(clientSocket);
close(serverSocket);
return 0;
}
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
char message[BUF_SIZE];
int str_len, i;
struct sockaddr_in serv_adr;
struct sockaddr_in clnt_adr;
socklen_t clnt_adr_sz;
if(argc!=2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock=socket(PF_INET, SOCK_STREAM, 0);
if(serv_sock==-1)
error_handling("socket() error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
clnt_adr_sz=sizeof(clnt_adr);
for(i=0; i<5; i++)
{
clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
if(clnt_sock==-1)
error_handling("accept() error");
else
printf("Connected client %d \n", i+1);
while((str_len=read(clnt_sock, message, BUF_SIZE))!=0)
write(clnt_sock, message, str_len);
close(clnt_sock);
}
close(serv_sock);
return 0;
}
int main(int argc, char* argv[])
{
int sock;
char message[BUF_SIZE];
int str_len;
struct sockaddr_in serv_adr;
if (argc != 3)
{
std::cout<<"ip port error"<<std::endl;
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if(sock == -1)
{
error_handling("socket() error");
}
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
serv_adr.sin_port = htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
{
error_handling("connect error");
}
else
puts("connecting ...");
while(1)
{
fputs("Input message (q to exit):", stdout);
fgets(message, BUF_SIZE, stdin);
if(!strcmp(message, "q\n") || !strcmp(message,"Q\n"))
{
break;
}
write(sock, message, strlen(message));
str_len = read(sock, message, BUF_SIZE -1);
std::cout<<"message :" << message << std::endl;
}
close(sock);
return 0;
}
