'전체 글'에 해당되는 글 392건

버퍼링은 상대입장에서 남은 용량을 보고 받고 

내가 보내려는 양에서 뚝 때서 조금씩 보내주는중임

입력 햇다고 바로 가는게 아니라 저장소에 잠시 저장 되고 조금씩 보내줌

보내는애랑  받는애의 끝남은

받는는애가 끝네겟다고 하면

보내는애가 끝넬지 말지 생각함

보낼꺼 있으면 계속 보내기만함

보낼꺼 없어지면 나도 끝네겟다고함

그러럼 받는애가 알앗다고 끊음

전에 그거 해결 하려면

보낸애가  보낸 크기만큼 읽을때까지 기다리면 되는거지 ㅇㅇ

그럼 받는애가 끊어서 받든 다 받든 상관없이 

내가 보낸 만큼 읽어졋을때 맞는지 틀리는지 알수 있으니깐

이거는echo_client2.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sock;
    char message[BUF_SIZE];
    int str_len, recv _len, recv_cnt;
    struct sockaddr_in serv_adr;
    
    if(argc!=3) {
    	printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }
    
    sock=socket(PF_INET, SOCK_STRAM, 0);
    if(sock==-1)
    	error_handling("socket() error");
    
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INT;
    serv_adr.sin_addr.s_addr=int_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
    	put("connected...........");
    
    while(1)
    {
    	fputs("Input message(Q to quit): ", stdout);       // stdout 이거 어디서 나온거지?
        fgets(message, BUF_SIZE, stdin);
        if(!strcmp(message,"q\n") || ! strcmp(message,"Q\n"))    // cmp? 알아봐야할듯
        	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_cnt]=0;
        printf("Message from server: %s", messeage);
   }
   close(sock);
   return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

밑은 op_client.c임

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
#define RLT_SIZE 4
#define OPSZ 4
void error_handling(char *message);

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) 
    {                                             //이거 3이 뭔뜻이엿지?
    	printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }
    
    sock=socket(PF_INET, SOCK_STRAM, 0);
    if(sock==-1)
    	error_handling("socket() error");
    
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INT;
    serv_adr.sin_addr.s_addr=int_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
    	put("connected...........");
    
    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]);    //이거 뭐지배열 추가인가?
    }
    fgetc(stdin);
    fputs("Operator: ", stdout);
    scanf("%c", &opmsg[opnd_cnt*OPSZ+1]);
    write(sock, opmsg, opnd_cnt*OPSZ+2);
    read(sock, &result, RLT_SIZE);
     
    printf("Operation result: %d \n", result);                 // 왜 주소지???
    close(sock);
    return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

살짝 다르긴 한데 뭐 비슷비슷한듯함

추가건

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
#define OPSZ 4
void error_handling(char *message);
int calculate(int opnum, int opnds[], chart oprator);

int main(int argc, 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_adr, 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");
        
    memsetr(&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++)                //저위에 선언되있움
    {
    	opnd_cnt=0;
        clnt_sock=accept(serv_sock, (struct sockaddr*&)&clnt_adrt, &clnt_adr_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 calculate(int opnum, int opnds[], chart oprator)
{
	int result=opnds[0], i;
    switch(op)
    {
    case '+':
    	for(i=1; i<opnum; i++) result+=opnds[i];
        break;
    case '-':
    	for(i=1; i<opnum; i++) result-=opnds[i];
        break;
    case '*':
    	for(i=1; i<opnum; i++) result*=opnds[i];
        breadk;
    }
    return result;
}   

void error_handling(char *message)
{
	fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

아

다썻다 

하야케 불태웟어~~

으아ㅏ으아아ㅏㅇ

어느정도 이해가 되었다 음 계산기는 왜만들었을까 참 궁금하다

아 겜한판 하고 담에 또해야지

이제 하나 만 보내고 

하나 만 받는 소켓은

지겹다

걍 끝날때까지 계속 연결되있는 상황을 만드려면

accept 함수를 계쏙 다시 하는거임

그럼 위에꺼는 안해도 되잖아 

accept 로 소켓 하나씩 만들고 받으면서 

계속 연결되있는 상태로 만듬

줄서서 순서대로 서비스 제공하는 소켓 임

근데 읽는애는 조금 읽고 

주는애는 많이 주면 

이게 읽는애가 읽은만큼만 주는애가 들으면 다시보내겟지뭐

주는애                                      ----------------->  읽는애 

야 너 오늘 데이트간다며               -----------------> 야 너 오늘 

야 너 오늘                               <----------------   야 너 오늘 

???????????이거 아닌데 잘못 들엇나?          

                                                    들읽은거 --- 데이트간다며

아니 그게 아니고 ----------> 잠시 저장됨 ---대기중 >

(전달 안된줄 알고 또보넴)

데이트 간다며                         <--------------- 데이트간다며

????????????????? 아.......

이런식인듯 

#listen <sys/type.h>

int listen(int sock, int backlog);

sock 연결 요청대기상태에 두고자 하는 소켓의 파일 디스크립터 전달 ,이함수의 인자로 전달된 디스트립터의 소켓이 서버 소켓(리스닝) 이 된다

backlog 연결 요청 대기 큐(Queue)의 크기정보 전달, 5가 전달되면 큐의 크기가 5가 되어 클라이언트 의 연결요청을 5갸까지 대기시킬 수 있다.

그니깐

sock 은 오는 데이터 경비실 아저씨가 받아서 택배아져씨처럼 잘 분배해주고

backlog 는 우체통임 ㅇㅇ

????

 말달라졋음    

우체통이 아니라 그 뭐냐 호실 주인하고 우체국 아져씨하고 이어줌 

CPU는 PORT 를 중복 시킬수 있다 좀 신기하네 우린 못해 컴터만 할 수있음

운영 체제는 맵 핑 주소를 가지고 있어서 가능하다고 한다 뭔개소리야???

211.217.218.90 :8080

그니깐 보낸에마다 나눠서 주는건가 

집주인의 엄마 아빠 아들 딸 있으면 집에는 연결하는데 딸친구와서 딸하고 이어주고

엄마 친구는 엄마하고 이어주고 그니깐

저장한 정보로 맞는 사람하고 이어줌

#include <sys/socket.h>

int accept(int sock, struct sockaddr * addr, socklen_t * addrlen);

음 그림으로 이해하자 

TCP/ IP 프로토콜 스택

스택 이건 약속임

왜만들어졋음 ??

인터넷 기반의 데이터 송수신을 차곡차곡 쌓아놧움

계층적 관계를 이용하여 구성하고 있다

큰거를 나눠서 하나하나 해결하는듯

7계층으로 나눠서 예기해야하는데

4계로 나눠서 예기하겟다고함

APPPLICATION 계층   ===== 응용계층

   |               | 

TCP 계층  UDP 계층  =====  전송 계층

            | 

      IP 계층       ===== 라우터 라우팅?? 데이터를 목적지까지 보네는 알고리즘  

           |                        이건 표준화 햇데  뭔말인지 몰라도 약속인듯

   LINK 계층   =====  물리적 계층 임 장비연결되있는거

위에서 보듯이 TCP 랑 UDP 두갈래의 길이있다

TCP 데이터 송수신 방법을 정하고

TCP===IP===LINK 를 묶어서 자동 소켓을 만듬

TCP 

호스트 A               호스트 B

W: 야~!!!                R:야~!!

R: ?                       W:?                이렇게 확인함

W: 음잘되네           R: 음잘되네       

R: ?                        W: ?

===========================

W: 야~!!!                R:야~!!!

                                       이렇게 확인이 안되면 계속 부름

W: 야~!!!!!!           R: 야~!!!!!!

R: ?                    W: ?              이렇게 될때까지함