설명

int main(int argc, char *argv)
{
    char *buffer = "In the UNIX environment a thread: \n" \
        "Exists within a process and uses the process resources\n" \
        "Has its own independent flow of control as long as its parent process exists and the OS supports it\n" \
        "May share the process resources with other threads that act equally independently (and dependently)\n" \
        "Dies if the parent process dies - or something similar\n";

    packet_dump(buffer, strlen(buffer), 16);
}

$ ./packet_dump
[   0] 49 6e 20 74 68 65 20 55-4e 49 58 20 65 6e 76 69   In the UNIX envi
[   1] 72 6f 6e 6d 65 6e 74 20-61 20 74 68 72 65 61 64   ronment a thread
[   2] 3a 20 0d 0a 45 78 69 73-74 73 20 77 69 74 68 69   : ..Exists withi
[   3] 6e 20 61 20 70 72 6f 63-65 73 73 20 61 6e 64 20   n a process and
[   4] 75 73 65 73 20 74 68 65-20 70 72 6f 63 65 73 73   uses the process
[   5] 20 72 65 73 6f 75 72 63-65 73 0d 0a 48 61 73 20    resources..Has
[   6] 69 74 73 20 6f 77 6e 20-69 6e 64 65 70 65 6e 64   its own independ
[   7] 65 6e 74 20 66 6c 6f 77-20 6f 66 20 63 6f 6e 74   ent flow of cont
[   8] 72 6f 6c 20 61 73 20 6c-6f 6e 67 20 61 73 20 69   rol as long as i
[   9] 74 73 20 70 61 72 65 6e-74 20 70 72 6f 63 65 73   ts parent proces
[  10] 73 20 65 78 69 73 74 73-20 61 6e 64 20 74 68 65   s exists and the
[  11] 20 4f 53 20 73 75 70 70-6f 72 74 73 20 69 74 0d    OS supports it.
[  12] 0a 4d 61 79 20 73 68 61-72 65 20 74 68 65 20 70   .May share the p
[  13] 72 6f 63 65 73 73 20 72-65 73 6f 75 72 63 65 73   rocess resources
[  14] 20 77 69 74 68 20 6f 74-68 65 72 20 74 68 72 65    with other thre
[  15] 61 64 73 20 74 68 61 74-20 61 63 74 20 65 71 75   ads that act equ
[  16] 61 6c 6c 79 20 69 6e 64-65 70 65 6e 64 65 6e 74   ally independent
[  17] 6c 79 20 28 61 6e 64 20-64 65 70 65 6e 64 65 6e   ly (and dependen
[  18] 74 6c 79 29 0d 0a 44 69-65 73 20 69 66 20 74 68   tly)..Dies if th
[  19] 65 20 70 61 72 65 6e 74-20 70 72 6f 63 65 73 73   e parent process
[  20] 20 64 69 65 73 20 2d 20-6f 72 20 73 6f 6d 65 74    dies - or somet
[  21] 68 69 6e 67 20 73 69 6d-69 6c 61 72 0d 0a         hing similar..
$

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

void packet_dump(char* buf, int size, int unit)
{
     char     tmp[150];
     char     msg[256];
     int      i, j, lno;

     j = 7;
     lno = 0;
     memset((tmp+0), 0x00, 150);
     
     for (i = 0; i < size; i++) {
          if((i%unit) == 0)
               memset((tmp+0), 0x20, ((unit*3)+unit+1+7+3));
          if(j == 7)
               sprintf((tmp+0), "[%4d] ", lno);
          sprintf((tmp+j), "%02x", (unsigned char)*(buf+i));
          tmp[j+2] = 0x20;
          if((unsigned char)*(buf+i) >= (unsigned char)0x20)
               tmp[(j/3)+(unit*3)+1+6] = *(buf+i);
          else
               tmp[(j/3)+(unit*3)+1+6] = '.';
          j += 3;
          if((i%unit) == (unit-1)) {
               printf("%s\n", (tmp+0));
               j = 7;
               ++lno;
          }
          else if((i%unit) == ((unit/2)-1))
               tmp[j-1] = '-';
     }
     
     if ((i % unit) != 0) {
     printf("%s\n", (tmp+0));
     }
}

이올린에 북마크하기(0) 이올린에 추천하기(0)

절대적 공감....

이올린에 북마크하기(0) 이올린에 추천하기(0)

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define ERR_MSG "usage : move file1 file2\n"

int main(int argc ,char *argv[]){

 if(argc != 3){
  fprintf(stderr,"%s",ERR_MSG);
  exit(1);
 }
 
 else{
  if(link(argv[1],argv[2])==-1){
   perror("LINK ERROR :");
   exit(1);
  }
 
  if(unlink(argv[1])==-1){
   perror("UNLINK_ERR : REMOVE FILE IMPOSBLE");
   exit(1);
  }
 
  printf("SUCCESS MOVE : %s -> %s",argv[1],argv[2]);
  exit(0);
 }
 return 0;
}
 
 

이올린에 북마크하기(0) 이올린에 추천하기(0)

void PrintNetData(FILE * fp, u_char * start, const int len)
{
    char *end;          /* ptr to buffer end */
    int i;          /* counter */
    int j;          /* counter */
    int dbuf_size;      /* data buffer size */
    int done;           /* flag */
    char *data;         /* index pointer */
    char *frame_ptr;        /* we use 66 byte frames for a printed line */
    char *d_ptr;        /* data pointer into the frame */
    char *c_ptr;        /* char pointer into the frame */
    char conv[] = "0123456789ABCDEF";   /* xlation lookup table */

    /* initialization */
    done = 0;

   /* zero, print a <CR> and get out */
    if(!len)
    {
        fputc('\n', fp);
        return;
    }

    if(start == NULL)
    {
        printf("Got NULL ptr in PrintNetData()\n");
        return;
    }
  
    end = (char*) (start + (len - 1));    /* set the end of buffer ptr */

    if(len > IP_MAXPACKET)
    {
        if(pv.verbose_flag)
        {
            printf("Got bogus buffer length (%d) for PrintNetData, defaulting to 16 bytes!\n", len);
        }

        if(pv.verbose_bytedump_flag == 1)
        {
            dbuf_size = (FRAME_SIZE + 8) + (FRAME_SIZE + 8) + 1;
        }
        else
        {
            dbuf_size = FRAME_SIZE + FRAME_SIZE + 1;
        }

        /* dbuf_size = 66 + 67; */
        end =  (char*) (start + 15);
    }
    else
    {
        if(pv.verbose_bytedump_flag == 1)
        {
            /* figure out how big the printout data buffer has to be */
            dbuf_size = ((len / 16) * (FRAME_SIZE + 8)) + (FRAME_SIZE + 8) + 1;
        }
        else
        {
            /* figure out how big the printout data buffer has to be */
            dbuf_size = ((len / 16) * FRAME_SIZE) + FRAME_SIZE + 1;
        }

        /* dbuf_size = ((len / 16) * 66) + 67; */
    }

    /* generate the buffer */
    //data_dump_buffer = (char *) malloc(dbuf_size);
    if (data_dump_buffer == NULL)
    {
        AllocDumpBuf();
    }

    /* clean it out */
    memset(data_dump_buffer, 0x20, dbuf_size);

    /* set the byte buffer pointer to step thru the data buffer */
    data = (char*) start;

    /* set the frame pointer to the start of the printout buffer */
    frame_ptr = data_dump_buffer;

    /* initialize counters and frame index pointers */
    i = 0;
    j = 0;

    /* loop thru the whole buffer */
    while(!done)
    {
        if(pv.verbose_bytedump_flag == 1)
        {
            d_ptr = frame_ptr + 8;
            c_ptr = (frame_ptr + 8 + C_OFFSET);
            sprintf(frame_ptr, "0x%04X: ", j);
            j += 16;
        }
        else
        {
            d_ptr = frame_ptr;
            c_ptr = (frame_ptr + C_OFFSET);
        }

        /* process 16 bytes per frame */
        for(i = 0; i < 16; i++)
        {
            /*
             * look up the ASCII value of the first nybble of the current
             * data buffer
             */
            *d_ptr = conv[((*data & 0xFF) >> 4)];
            d_ptr++;

            /* look up the second nybble */
            *d_ptr = conv[((*data & 0xFF) & 0x0F)];
            d_ptr++;

            /* put a space in between */
            *d_ptr = 0x20;
            d_ptr++;

            /* print out the char equivalent */
            if(*data > 0x1F && *data < 0x7F)
                *c_ptr = (char) (*data & 0xFF);
            else
                *c_ptr = 0x2E;

            c_ptr++;

            /* increment the pointer or finish up */
            if(data < end)
                data++;
            else
            {
                *c_ptr = '\n';
                c_ptr++;
                *c_ptr = '\n';
                c_ptr++;
                *c_ptr = 0;

                dump_size = (int) (c_ptr - data_dump_buffer);
                fwrite(data_dump_buffer, dump_size, 1, fp);

                //ClearDumpBuf();
                return;
            }
        }

        *c_ptr = '\n';
        if(pv.verbose_bytedump_flag == 1)
        {
            frame_ptr += (FRAME_SIZE + 8);
        }
        else
        {
            frame_ptr += FRAME_SIZE;
        }
    }

    //ClearDumpBuf();
}

void PrintCharData(FILE * fp, char *data, int data_len)
{
    int bytes_processed;    /* count of bytes in the data buffer
                 * processed so far */
    int linecount = 0;      /* number of lines in this dump */
    char *index;        /* index pointer into the data buffer */
    char *ddb_ptr;      /* index pointer into the data_dump_buffer */
    int size;

    /* if there's no data, return */
    if(data == NULL)
    {
        return;
    }

    /* setup the pointers and counters */
    bytes_processed = data_len;
    index = data;

    /* allocate a buffer to print the data to */
    //data_dump_buffer = (char *) calloc(data_len + (data_len >> 6) + 2, sizeof(char));
    if (data_dump_buffer == NULL)
    {
        AllocDumpBuf();
    }

    size = (data_len + (data_len >> 6) + 2) * sizeof(char);

    /* Based on data_len < 65535, this should never happen, but check just in
     * case sizeof(char) is big or something. */
    if (data_dump_buffer_size < size)
    {
        data_dump_buffer_size = size;
        ClearDumpBuf();

        /* Reallocate for a bigger size. */
        AllocDumpBuf();
    }

    /* clean it out */
    memset(data_dump_buffer, 0x20, size);

    ddb_ptr = data_dump_buffer;

    /* loop thru the bytes in the data buffer */
    while(bytes_processed)
    {
        if(*index > 0x1F && *index < 0x7F)
        {
            *ddb_ptr = *index;
        }
        else
        {
            *ddb_ptr = '.';
        }

        if(++linecount == 64)
        {
            ddb_ptr++;
            *ddb_ptr = '\n';
            linecount = 0;
        }
        ddb_ptr++;
        index++;
        bytes_processed--;
    }

    /* slam a \n on the back */
    ddb_ptr++;
    *ddb_ptr = '\n';
    ddb_ptr++;

    /* setup the globals */

    dump_size = (int) (ddb_ptr - data_dump_buffer);
    fwrite(data_dump_buffer, dump_size, 1, fp);

    //ClearDumpBuf();
}

이올린에 북마크하기(0) 이올린에 추천하기(0)

1.1절. 사용법

#include <sys/types.h>
#include <sys/socket.h>

int socket(int domain, int type, int protocol);
		

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

int main(int argc, char **argv)
{
    int server_sockfd, client_sockfd;
    int state, client_len;

    struct sockaddr_in clientaddr, serveraddr, myaddr;


    // internet 기반의 스트림 소켓을 만들도록 한다. 
    // server_sockfd 는 endpoint 소켓(듣기 소켓) 으로 사용된다. 
    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error : ");
        exit(0);
    }
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(12345);

    // 듣기 소켓에 소켓특성(주소, 포트)를 묶어준다. 
    state = bind(server_sockfd , (struct sockaddr *)&serveraddr, 
            sizeof(serveraddr));
    if (state == -1)
    {
        perror("bind error : ");
        exit(0);
    }

    state = listen(server_sockfd, 5);
    if (state == -1)
    {
        perror("listen error : ");
        exit(0);
    }

    // 만약 듣기 소켓으로 클라이언트 연결이 들어왔다면, 
    // 새로운 클라이언트와의 통신을 위한 소켓 지정번호를 할당한다. 
    client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr, 
                           &client_len);
    if (client_sockfd == -1)
    {
        perror("Accept error : ");
        exit(0);
    }
    // 여기에서 부터는 클라이언트와의 통신
    // .....
    // .....

    close(client_sockfd);
    return 1;
}

이올린에 북마크하기(0) 이올린에 추천하기(0)

1.1절. 사용법

#include <sys/types.h>
#include <sys/socket.h>

int  sendto(int s, const void *msg, size_t len, int flags,
       const struct sockaddr *to, socklen_t tolen);
		

#include <sys/socket.h>
#include <sys/stat.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    int server_sockfd, client_sockfd;
    int client_len, n;
    char buf[80];
    struct sockaddr_in clientaddr, serveraddr;

    client_len = sizeof(clientaddr);

    if ((server_sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error : ");
        exit(0);
    }
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(atoi(argv[1]));

    bind (server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(server_sockfd, 5);

    while(1)
    {
        memset(buf, 0x00, 80);
        client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr,
                            &client_len);

        if ((n = read(client_sockfd, buf, 80)) <= 0)
        {
            close(client_sockfd);
            continue;
        }
        sendto(client_sockfd,(void *)buf, 80, 0,
                        NULL, client_len);
        close(client_sockfd);
    }
}
		

이올린에 북마크하기(0) 이올린에 추천하기(0)