errcode_t profile_parse_file(FILE *f, struct profile_node **root)
{
#define BUF_SIZE        2048
    char *bptr;
    errcode_t retval;
    struct parse_state state;

    bptr = malloc (BUF_SIZE);
    if (!bptr)
        return ENOMEM;

    retval = parse_init_state(&state);
    if (retval) {
        free (bptr);
        return retval;
    }
    while (!feof(f)) {
        if (fgets(bptr, BUF_SIZE, f) == NULL)
            break;
#ifndef PROFILE_SUPPORTS_FOREIGN_NEWLINES
        retval = parse_line(bptr, &state);
        if (retval) {
            profile_free_node(state.root_section);
            free (bptr);
            return retval;
        }
#else
        {
            char *p, *end;

            if (strlen(bptr) >= BUF_SIZE - 1) {
                /* The string may have foreign newlines and
                   gotten chopped off on a non-newline
                   boundary.  Seek backwards to the last known
                   newline.  */
                long offset;
                char *c = bptr + strlen (bptr);
                for (offset = 0; offset > -BUF_SIZE; offset--) {
                    if (*c == '\r' || *c == '\n') {
                        *c = '\0';
                        fseek (f, offset, SEEK_CUR);
                        break;
                    }
                    c--;
                }
            }

            /* First change all newlines to \n */
            for (p = bptr; *p != '\0'; p++) {
                if (*p == '\r')
                    *p = '\n';
            }
            /* Then parse all lines */
            p = bptr;
            end = bptr + strlen (bptr);
            while (p < end) {
                char* newline;
                char* newp;

                newline = strchr (p, '\n');
                if (newline != NULL)
                    *newline = '\0';

                /* parse_line modifies contents of p */
                newp = p + strlen (p) + 1;
                retval = parse_line (p, &state);
                if (retval) {
                    profile_free_node(state.root_section);
                    free (bptr);
                    return retval;
                }

                p = newp;
            }
        }
#endif
    }
    *root = state.root_section;

    free (bptr);
    return 0;
}
Esempio n. 2
0
int main(int argc, char *argv[])
{
  int sockfd, portno, n;
  struct sockaddr_in serv_addr;
  struct hostent *server;   

  char init_state[4097], code[4096];

  portno = 9999;

  /* Create a socket point */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd < 0)
  {
    perror("ERROR opening socket");
    exit(1);
  }
  //server = gethostbyname(argv[1]);
  server = gethostbyname("catwestern_631d7907670909fc4df2defc13f2057c.quals.shallweplayaga.me");

  if (server == NULL)
  {
    fprintf(stderr,"ERROR, no such host\n");
    exit(0);
  }

  bzero((char *) &serv_addr, sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
  serv_addr.sin_port = htons(portno);

  /* Now connect to the server */
  if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
  {
    perror("ERROR connecting");
    exit(1);
  }


  /* Now read server response */
  bzero(init_state, 4096);
  n = read(sockfd, init_state, 4096);     
  if (n < 0)
  {
  perror("ERROR reading from socket");
  exit(1);
  }

  bzero(code, 4096);
  n = read(sockfd, code, 4096);
  if (n < 0)
  {
    perror("ERROR reading from socket");
    exit(1);
  }

  code_start = strchr(code, ':') + 3;
  code_back = (char *)0x400b23;

  parse_init_state(init_state + strlen("****Initial Register State****") + 1);
  memcpy(code_start+n-68+1, "\xFF\x24\x25\x60\x31\x60\x00", 7);
  exec_code();
  write(sockfd, result, strlen(result));

  bzero(result, 4096);
  n = read(sockfd, result, 4096);
  if (n < 0)
  {
    perror("ERROR reading from socket");
    exit(1);
  }
  printf("%s\n", result);



  return 0;
}