Block Busting

====

Junior Programmer:
if (m==1){Month="January")}
if (m==2){Month="February")}
if (m==3){Month="March")}
if (m==4){Month="April")}
if (m==5){Month="May")}
if (m==6){Month="June")}
if (m==7){Month="July")}
if (m==8){Month="August")}
if (m==9){Month="September")}
if (m==10){Month="October")}
if (m==11){Month="November")}
if (m==12){Month="December")}
---------------------------------------------------------------
Senior Programmer:
switch(m)
{
case 1:
Month = "January"
break;
case 2:
Month = "February"
break;
case 3:
Month = "March"
break;
case 4:
Month = "April"
break;
case 5:
Month = "May"
break;
case 6:
Month = "June"
break;
case 7:
Month = "July"
break;
case 8:
Month = "August"
break;
case 9:
Month = "September"
break;
case 10:
Month = "October"
break;
case 11:
Month = "November"
break;
case 12:
Month = "December"
break;
default:
Month = "unknown"
}
---------------------------------------------------------------
Lazy Programmer:
MonthNames == ["","January","February","March",...]
Month = MonthNames[m]

====

----

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

    int client_len;
    int client_sockfd;
    char buf[256];
    struct sockaddr_in clientaddr;

    clientaddr.sin_family = AF_INET;
    clientaddr.sin_addr.s_addr = inet_addr("100.10.1.57");
    clientaddr.sin_port = htons(8002);
    client_len = sizeof(clientaddr);

    client_sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (connect (client_sockfd, (struct sockaddr *)&clientaddr,
                client_len) < 0)
    {
        perror("connect error :");
        exit(0);
    }

    int nbyte;
    size_t filesize = 0, bufsize = 0;
    FILE *file = NULL;

    file = fopen("test.jpg", "wb");

    ntohl(filesize);
    recv(client_sockfd, &filesize, sizeof(filesize), 0);
    printf("file size = [%d]\n", filesize);
    bufsize = 256;
    while(filesize != 0)
    {
        if(filesize < 256)
            bufsize = filesize;

        nbyte = recv(client_sockfd, buf, bufsize, 0);
        filesize = filesize -nbyte;

        fwrite(buf, sizeof(char), nbyte, file);

        nbyte = 0;

    }

    close(client_sockfd);
    fclose(file);
    return 0;
}

----

int main(int argc, char **argv)
{
    int server_sockfd, client_sockfd;
    int state, client_len;
    size_t fsize = 0, nsize = 0, fpsize = 0;
    size_t fsize2 = 0;
    size_t fsize3 = 0;
    FILE *file = NULL;

    int ret;
    struct stat file_stat;

    struct sockaddr_in clientaddr, serveraddr;

    char buf[256];
    memset(buf, 0x00, 256);
    state = 0;

    client_len = sizeof(clientaddr);

    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error : ");
        exit(0);
    }

    memset(&serveraddr,0x00, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(8002);

    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);
    }


    file = fopen("test.jpg", "rb");
    fseek(file, 0, SEEK_END);
    fsize = ftell(file);
    fseek(file, 0, SEEK_SET);

    /*
    ret = lstat("test.jpg", &file_stat);
    if (ret < 0) {
        return -1;
    }
    if (file_stat.st_size == 0) {
        return -1;
    }

    fsize3 = file_stat.st_size;
    printf("file size 1 [%d]\n", fsize);
    printf("file size 2 [%d]\n", fsize3);
    */

    client_sockfd = accept(server_sockfd,
            (struct sockaddr *)&clientaddr, &client_len);
    printf("file size [%d]\n", fsize);
    fsize2 = htonl(fsize);
    printf("file size [%d]\n", fsize2);

    send(client_sockfd, &fsize2, sizeof(fsize), 0);

    while(nsize != fsize)
    {
        fpsize = fread(buf, 1, 256, file);
        nsize = nsize+fpsize;
        send(client_sockfd, buf, fpsize, 0);
    }
    printf("file send \n");
    close(client_sockfd);
    fclose(file);

    return 0;
}

----

char test_char[16] = {0,};
int test_int = 10000;

snprintf( test_char, sizeof(test_char), "%s", test_int);

#define INT_DIGITS 19		/* enough for 64 bit integer */

char *itoa(i)
     int i;
{
  /* Room for INT_DIGITS digits, - and '\0' */
  static char buf[INT_DIGITS + 2];
  char *p = buf + INT_DIGITS + 1;	/* points to terminating '\0' */
  if (i >= 0) {
    do {
      *--p = '0' + (i % 10);
      i /= 10;
    } while (i != 0);
    return p;
  }
  else {			/* i < 0 */
    do {
      *--p = '0' - (i % 10);
      i /= 10;
    } while (i != 0);
    *--p = '-';
  }
  return p;
}

--------

#include 
#include 
int main ()
{
    int i;
    char compare_text[] = "123th";
    char character_set[] = "123456th123th";

    i = strspnn (compare_text, character_set);
    printf ("The length of initial number is [%d].\n", i);
    return 0;
}

#include "sys/cdefs.h"
#include 

/*
 * Span the string s2 (skip characters that are in s2).
 */
size_t
strspn(s1, s2)
        const char *s1;
        register const char *s2;
{
    register const char *p = s1, *spanp;
    register char c, sc;

    /*
     *   * Skip any characters in s2, excluding the terminating \0.
     *       */
cont:
    c = *p++;
    for (spanp = s2; (sc = *spanp++) != 0;)
        if (sc == c)
            goto cont;
    return (p - 1 - s1);
}

#include 
#include 

int main()
{
    char *temp1 ="HPUX";
    char *temp2="LINUX";
    char *temp3 ="SOLARIS";

    printf("s1[%7s], s1[%7s]  ret =[%2d]\n", temp1, temp2, strcmp(temp1,temp2));
    printf("s2[%7s], s3[%7s]  ret =[%2d]\n", temp2, temp3,  strcmp(temp2,temp3));
    printf("s3[%7s], s1[%7s]  ret =[%2d]\n", temp3, temp1,  strcmp(temp3,temp1));

    return 0;
}

[ 결과 값 ] 
$ ./a.out 
s1[   HPUX], s1[  LINUX]  ret =[-1]
s2[  LINUX], s3[SOLARIS]  ret =[-1]
s3[SOLARIS], s1[   HPUX]  ret =[ 1]

#import 

/* This routine should be optimized. */

/* ANSI sez:
 *   The `strcmp' function compares the string pointed to by `s1' to the
 *   string pointed to by `s2'.
 *   The `strcmp' function returns an integer greater than, equal to, or less
 *   than zero, according as the string pointed to by `s1' is greater than,
 *   equal to, or less than the string pointed to by `s2'.  [4.11.4.2]
 */
int
strcmp(const char *s1, const char *s2)
{
    for ( ; *s1 == *s2; s1++, s2++)
	if (*s1 == '\0')
	    return 0;
    return ((*(unsigned char *)s1 < *(unsigned char *)s2) ? -1 : +1);
}

#include 
#include 

int main()
{
    int delim = 'w';
    char *ret = NULL;
    const char *str = "august wednesday";


    ret = strchr(str, delim);
    if(ret == NULL) {
        printf("No [%c] in string\n", (char)delim);
        return -1;
    }
    else
        printf("Found[%c]\n"
               "Start point==> [%s]\n",
               (char)delim, ret);


    return 0;
}

#include 

char *
strchr (s, c)
  register const char *s;
  int c;
{
  do {
    if (*s == c)
      {
	return (char*)s;
      }
  } while (*s++);
  return (0);
}

#include 
#include 

int main()
{
    char *me;
    me = strdup("who am I");
    printf("%s\n", me);

    return 0;
}

#if HAVE_CONFIG_H
# include 
#endif

#ifdef STDC_HEADERS
# include 
# include 
#else
char *malloc ();
char *strcpy ();
#endif

/* Return a newly allocated copy of STR,
   or 0 if out of memory. */

char *
strdup (const char *str)
{
  char *newstr;

  newstr = (char *) malloc (strlen (str) + 1);
  if (newstr)
    strcpy (newstr, str);
  return newstr;
}