img_demo.c

eCos操作系统源码

    int fd, len, err;
    struct sockaddr_in srvr_addr;

    buf += 3;  // Skip over command
    fn = strtok(buf, " ,");
    sn = strtok(NULL, " ,");
    if ((fn == (char *)NULL) || (sn == (char *)NULL)) {
        fdprintf(client, "usage: get <file> <server>\n");
        return;
    }
    // For now, only numeric IP addresses
    if (!inet_aton(sn, &srvr_addr.sin_addr)) {
        fdprintf(client, "Can't get host info: %s\n", sn);
        return;
    }
    srvr_addr.sin_port = 0;
    if ((data = (char *)malloc(0x100000)) == (char *)NULL) {
        fdprintf(client, "Can't allocate temp buffer\n");
        return;
    }
    if ((len = tftp_get(fn, &srvr_addr, data, 0x100000, TFTP_OCTET, &err)) > 0) {
        fdprintf(client, "Read %d bytes\n", len);
        fd = open(fn, O_RDWR|O_CREAT);
        if (fd > 0) {
            err = write(fd, data, len);
            if (err != len) {
                fdprintf(client, "Error writing data\n");
            }
            close(fd);
        } else {
            fdprintf(client, "Can't create \"%s\"\n", fn);
        }
#ifdef CYGPKG_FS_RAM
        sprintf(_fn, "/%s", fn);
        fd = open(_fn, O_RDWR|O_CREAT);
        if (fd > 0) {
            err = write(fd, data, len);
            if (err != len) {
                fdprintf(client, "Error writing data\n");
            }
            close(fd);
        } else {
            fdprintf(client, "Can't create \"%s\"\n", _fn);
        }
#endif
    } else {
        fdprintf(client, "Error reading data\n");
    }
    free(data);
}

static void
do_rm(int client, char *buf)
{
    char *fn;

    buf += 2;  // Skip over command
    fn = strtok(buf, " ,");
    if (fn == (char *)NULL) {
        fdprintf(client, "usage: rm <file>\n");
        return;
    }
    if (unlink(fn) < 0) {
        fdprintf(client, "Can't remove \"%s\": %s\n", fn, strerror(errno));
    }
}

static void
do_cmd(int client, char *buf)
{
    char *cp = buf+strlen(buf)-1;
    while ((*cp == '\n') || (*cp == '\r')) {
        *cp-- = '\0';  // Remove trailing terminators
    }
    printf("Command: %s\n", buf);
    if (strncmp(buf, "ls", 2) == 0) {
        do_ls(client, buf);
    } else
    if (strncmp(buf, "show_all", 8) == 0) {
        do_show_all(client, buf);
    } else
    if (strncmp(buf, "show", 4) == 0) {
        do_show(client, buf);
    } else
    if (strncmp(buf, "time", 4) == 0) {
        do_time(client, buf);
    } else
    if (strncmp(buf, "get", 3) == 0) {
        do_get(client, buf);
    } else
    if (strncmp(buf, "rm", 2) == 0) {
        do_rm(client, buf);
    } else
    {
        fdprintf(client, "Unknown command: %s\n", buf);
    }
}

static void
do_copy_file(char *src, char *dst)
{
    int err, srcfd, dstfd, len;
    char *buf;

#define COPY_SIZE 0x1000
    if ((srcfd = open(src, O_RDONLY)) >= 0) {
        if ((dstfd = open(dst, O_RDWR|O_CREAT)) >= 0) {
            if ((buf = (char *)malloc(COPY_SIZE)) != (char *)NULL) {
                while ((len = read(srcfd, buf, COPY_SIZE)) > 0) {
                    write(dstfd, buf, len);
                }
                free(buf);
            } else {
                diag_printf("Can't allocate working buffer\n");
            }
            close(srcfd);
            close(dstfd);
        } else {                        
            diag_printf("Can't create \"%s\": %s\n", dst, strerror(errno));
            close(srcfd);
        }
    } else {
        diag_printf("Can't open \"%s\": %s\n", src, strerror(errno));
    }
}

static void
do_copy_all(char *src, char *dst)
{
    int err;
    DIR *dirp;
    char *c, *buf;

    diag_printf("Copy all files from %s to %s\n", src, dst);
    dirp = opendir(src);    
    if(dirp == NULL) {
        diag_printf("Can't open directory \"%s\"\n", src);
        return;
    }
    for(;;) {
        struct dirent *entry = readdir( dirp );
        char srcname[PATH_MAX];
        char dstname[PATH_MAX];
        
        if( entry == NULL )
            break;
        strcpy(srcname, src);
        strcpy(dstname, dst);
        if( !(src[0] == '/' && src[1] == 0 ) )
            strcat(srcname, "/" );
        if( !(dst[0] == '/' && dst[1] == 0 ) )
            strcat(dstname, "/" );
        strcat(srcname, entry->d_name );
        strcat(dstname, entry->d_name );
        if ((c = rindex(srcname, '.')) != (char *)NULL) {
            if (strcmp(c, ".jpg") == 0) {
                diag_printf("Copy %s => %s\n", srcname, dstname); 
                do_copy_file(srcname, dstname);
            }
        }
    }
    closedir(dirp);
}

static void
pexit(char *why)
{
    printf("Image demo thread exiting - %s\n", why);
    GrClose();
    cyg_thread_exit();
}

int 
img_demo_thread(CYG_ADDRWORD data)
{
    int err, s, client, client_len;
    struct sockaddr client_addr;
    struct sockaddr_in my_addr;
    struct addrinfo *ai, *addrs, hints;
    char buf[256], addr_buf[256];
    int one = 1;
    fd_set in_fds, src_fds;
    int num, len;
    struct timeval tv;

    INIT_PER_THREAD_DATA();

    printf("Image demo here\n");
#ifdef CYGPKG_FS_RAM
    // Stage files from JFFS2 image into RAM
    err = mount("", "/ramfs", "ramfs");        
    if (err >= 0) {
        do_copy_all("/", "/ramfs");
    } else {
        pexit("Can't mount RAMfs\n");
    }
    chdir("/ramfs");
#endif
    if(GrOpen() < 0) {
        fprintf(stderr, "Couldn't connect to Nano-X server\n");
        exit(1);
    }
    // Set up as a generic server, listening on TCP/7734
#if 0
    bzero(&hints, sizeof(hints));
    hints.ai_family = PF_UNSPEC;b
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;
    if ((err = getaddrinfo(NULL, "7734", &hints, &addrs)) != EAI_NONE) {
        diag_printf("can't getaddrinfo(): %s\n", gai_strerror(err));
        pexit("getaddrinfo");
    }
    s = socket(ai->ai_family, ai->ai_socktype, 0);
    if (s < 0) {
        pexit("stream socket");
    }
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
        pexit("setsockopt SO_REUSEADDR");
    }
    if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
        pexit("setsockopt SO_REUSEPORT");
    }
    if(bind(s, ai->ai_addr, ai->ai_addr->sa_len) < 0) {
        pexit("bind error");
    }
    listen(s, SOMAXCONN);
#else
    s = socket(AF_INET, SOCK_STREAM, 0);
    if (s < 0) {
        pexit("stream socket");
    }
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
        pexit("setsockopt SO_REUSEADDR");
    }
    if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
        pexit("setsockopt SO_REUSEPORT");
    }
    memset(&my_addr, 0, sizeof(my_addr));
    my_addr.sin_family = AF_INET;
    my_addr.sin_len = sizeof(my_addr);
    my_addr.sin_port = htons(7734);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    if(bind(s, (struct sockaddr *) &my_addr, sizeof(my_addr)) < 0) {
        pexit("bind error");
    }
    listen(s, SOMAXCONN);
#endif
    while (true) {
        // Wait for a connection
        FD_ZERO(&src_fds);
        FD_SET(s, &src_fds);
        tv.tv_sec = 15;
        tv.tv_usec = 0;
        num = select(s+1, &src_fds, 0, 0, &tv);
        if (num > 0) {
            client_len = sizeof(client_addr);
            if ((client = accept(s, (struct sockaddr *)&client_addr, &client_len)) < 0) {
                pexit("accept");
            }
            client_len = sizeof(client_addr);
            getpeername(client, &client_addr, &client_len);
            _inet_ntop(&client_addr, addr_buf, sizeof(addr_buf));
            diag_printf("connection from %s(%d)\n", addr_buf, ntohs(_inet_port(&client_addr)));
            fdprintf(client, "Hello %s(%d)\n", addr_buf, ntohs(_inet_port(&client_addr)));
            while (true) {
                fdprintf(client, "// Ready\n");
                tv.tv_sec = 5;
                tv.tv_usec = 0;
                FD_ZERO(&in_fds);
                FD_SET(client, &in_fds);
                num = select(client+1, &in_fds, 0, 0, &tv);
                if (num > 0) {
                    len = read(client, buf, sizeof(buf)-1);
                    if (len <= 0) {
                        diag_printf("Client read error: %s\n", strerror(errno));
                        break;
                    }
                    buf[len-1] = '\0';
                    do_cmd(client, buf);
                } else if (num == 0) {
                    fdprintf(client, "<IDLE> show_all\n");
                    do_show_all(client, "show_all .");
                } else {
                    perror("select");
                }
            }
            close(client);
            diag_printf("Connection with %s closed\n", addr_buf);
        } else if (num == 0) {
            // No connection within 15 seconds
            do_show_all(0, "show_all .");
        } else {
            diag_printf("select returned: %d\n", num);
            pexit("bad select");
        }
    }
}