void
determine_file_type( Stringlist *input_files )
{
int ierr;
struct stat buf;
if( input_files == NULL ) {
fprintf( stderr, "ncview: takes at least one file name as argument\n" );
useage();
exit( -1 );
}
if( netcdf_fi_confirm( input_files->string ) )
file_type = FILE_TYPE_NETCDF;
else
{
ierr = stat( input_files->string, &buf );
if( ierr == 0 ) {
fprintf( stderr, "ncview: can't recognize format of input file %s\n",
input_files->string );
exit( -1 );
}
else
{
fprintf( stderr, "ncview: can't open file %s",
input_files->string );
perror(" ");
exit( -1 );
}
}
}
void ValidateArgs(int argc,char** argv)
{
int i;
for(i=1;i<argc;i++)
{
if((argv[i][0] == '-') || (argv[i][0] == '/'))
{
switch(tolower(argv[i][1]))
{
case 'p':
iPort = atoi(&argv[i][3]);
break;
case 'i':
bInterface = TRUE;
if(strlen(argv[i]) > 3)
strcpy(szAddress,&argv[i][3]);
break;
case 'o':
bRecvOnly = TRUE;
break;
default:
useage();
break;
}
}
}
}
static int parse_options(int argc, char **argv){
int ch;
opterr = 0;
while (-1 != (ch = getopt(argc, argv, "d:p:i:h"))) {
switch(ch){
case 'd':
strcpy(target,optarg);
break;
case 'p':
if (!(dest_port = atoi (optarg)))
return -1;
break;
case 'i':
strcpy(interface0,optarg);
break;
case 'h':
useage();
break;
case '?':
default:
printf("wrong parameter.\n");
return -1;
}
}
return 0;
}
void doargs(int argc, char *argv[])
{
int i=1;
while (i<argc) {
switch((argv[i][0]=='-')?argv[i][1]:argv[i][0]) {
case 'd': dodata=1; break;
case 't': dodata=0; break;
case 'h':
default:
useage();
}
i++;
}
}
/*----------------------------------------------------------------------
Parameters:
Description:
----------------------------------------------------------------------*/
static int
get_option(int argc, char *argv[]) {
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
if (!strcasecmp(option, "-version")) {
printf("Version: %s\n", NMOVIE_VERSION);
exit(0);
}
StrUpper(option) ;
switch (*option) {
case '?':
case 'U':
useage() ;
exit(1) ;
break ;
case '1':
nocolor = 1 ;
break ;
}
return(nargs) ;
}
bool checkOptions(int argc,char** argv)
{
int opt = 0;
int options_index = 0;
while((opt = getopt_long(argc,argv,"dp:hv",long_options,&options_index)) != EOF)
{
switch(opt)
{
case 'd':
g_daemon = true;
break;
case 'p':
g_port = atoi(optarg);
break;
case 'h':
useage(argv[0]);
return false;
case 'v':
version();
return false;
}
}
return true;
}
int main(int argc, char* argv[]){
DIR *dir;
int ret;
if(argc < 5) useage();
destdir = argv[2];
suffix = argv[3];
cc = argv[4];
if(argc == 6){
flags = argv[5];
}
ret = zftw(argv[1], cbf);
/*
ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock;
if(ntot == 0)ntot = 1;
printf("regular files =\t %7ld, %5.2f %%\n", nreg, nreg*100.0/ntot);
printf("directories =\t %7ld, %5.2f %%\n", ndir, ndir*100.0/ntot);
printf("block special =\t %7ld, %5.2f %%\n", nblk, nblk*100.0/ntot);
printf("char special =\t %7ld, %5.2f %%\n", nchr, nchr*100.0/ntot);
printf("FIFOs =\t %7ld, %5.2f %%\n", nfifo, nfifo*100.0/ntot);
printf("symbolic links =\t %7ld, %5.2f %%\n", nslink, nslink*100.0/ntot);
printf("sockets =\t %7ld, %5.2f %%\n", nsock, nsock*100.0/ntot);
*/
exit(ret);
}
int main(int argc, char **argv)
{
int add_blank= 1;
int polyphone_support = 1;
int first_letter_only = 0;
int convert_double_char = 1;
int show_tones = 0;
while(1)
{
static struct option long_options[] =
{
{"disable-blank", no_argument, NULL, 'B'},
{"disable-polyphone", no_argument, NULL, 'P'},
{"firstletter-only", no_argument, NULL, 'f'},
{"convert-double-char", no_argument, NULL, 'd'},
{"show-tones", no_argument, NULL, 't'},
{"help", no_argument, NULL, 'h'},
{0,0,0,0}
};
int option_index = 0;
int c = getopt_long(argc, argv, "BPfdth", long_options, &option_index);
if (c == -1) break;
switch(c)
{
case 'B':
add_blank = 0;
break;
case 'P':
polyphone_support = 0;
break;
case 'f':
first_letter_only = 1;
break;
case 'd':
convert_double_char = 1;
break;
case 't':
show_tones = 1;
break;
case 'h':
useage();
return 0;
break;
default:
useage();
return 0;
break;
}
}
linereader reader = linereader_create(STDIN_FILENO);
int count;
while ((count = linereader_readline(reader)) != -1)
{
const char *line = reader->line_buffer;
hz2py(line, count, add_blank, polyphone_support, first_letter_only, convert_double_char, show_tones);
}
linereader_free(reader);
return 0;
}
int main(int argc, char **argv)
{
unsigned char rule=0xD0;//0x7c;
unsigned char t;
unsigned long cells = 1;
unsigned long temp;
unsigned char index;
unsigned char ncells = 16;
if (argc > 1)
{
if(argv[1][0] == '0' && argv[1][1] == 'x')
{
unsigned int a;
sscanf(argv[1],"%x",&a);
rule = (unsigned char)a;
}
else
{
rule = atoi(argv[1]);
}
if (argc > 2)
{
if(argv[2][0] == '0' && argv[2][1] == 'x')
{
unsigned int a;
sscanf(argv[2],"%x",&a);
cells = (unsigned short)a;
}
else
{
cells = atoi(argv[2]);
}
}
}
else
{
printf("No argument! \n");
useage();
return;
}
ruleprint(rule);
printf("use ctl+C to stop \n");
ncells--;
for(;;cells=temp<<1|temp>>ncells)
{
binprint(cells,ncells);
temp=0;
for(index=0;index<=ncells;index++)
{
//the idea is to shift the rule mask (w/rollover) according to the 3
//bits in the neighborhood at $index, mask that bit in the rule to
//then determine the next cell state and OR it into a temp value
// |cell state-----------------------------------------------|
// | rule mask ---------------------------------|
// |neighborhood ---------------------------|
temp |= ((rule & 1<<((cells>>index|cells<<(ncells-index+1) )&7) )>0)<<index;
}
usleep(100000);
}
}
int main(int argc, char **argv)
{
int re = -1;
char *ptouchdata = NULL;
int size;
int fd;
int ctpfile;
int i=0;
if(argc == 2)
{
fd = open(touch_dev, O_RDONLY);
if(fd < 0)
{
printf("Couldn't open '%s' (%s)\n", touch_dev, strerror(errno));
return -1;
}
ctpfile = open(argv[1], O_RDONLY);
if(ctpfile < 0)
{
printf("Couldn't open '%s' (%s)\n", argv[1], strerror(errno));
re = -2;
goto FDERROR;
}
size = lseek(ctpfile, 0, SEEK_END);
ptouchdata = malloc(size+sizeof(int));
if(ptouchdata == NULL)
{
re = -3;
goto CTPERROR;
}
lseek(ctpfile, 0, SEEK_SET);
int len = read(ctpfile, ptouchdata+sizeof(int), size);
if(len != size)
{
printf("read error %s\n", argv[1]);
re = -3;
goto MALLOCERROR;
}
*((int *)ptouchdata)=size;
printf("upgrade ...\n");
for(i=0;i<MAX_TRY;i++)
{
int err = ioctl(fd, TPD_UPGRADE_CKT, ptouchdata);
if(err)
{
printf("error TPD_UPGRADE_CKT %d %d\n", i,err);
}
else
{
printf("done\n");
break;
}
}
}
else
{
useage();
return 0;
}
MALLOCERROR:
free(ptouchdata);
ptouchdata=NULL;
CTPERROR:
close(ctpfile);
FDERROR:
close(fd);
return re;
}
int main(int argc, char *argv[]){
/*
変数の定義
コマンドライン引数関連: http://www.fireproject.jp/feature/c-language/basic-library/getargs.html
ff: File Format: 入力された音のデータについて定義, raw か wavかで読み取る方法を変えている
*/
int opt;
int ff;
int cutopt=0;
FILE *fp;
char input[STRLEN];
char config[STRLEN];
char annotation[STRLEN];
char wav[] = ".wav";
char raw[] = ".raw";
char *check;
char outputsound[STRLEN];
strcpy(saveid,"unknown.wav");
strcpy(annot,"unknown.txt");
amp_flag = 0;
WAVE wave;
MIX mix;
MEM mem;
//abcdefghijklmnopqrstuvwxyz
//while((opt = getopt(argc, argv, "i:l:n:N:h:t:?:w:s:")) != -1){
snr = 999;
while((opt = getopt(argc, argv, "A:a:b:e:l:r:o:O:?h")) != -1){
switch(opt){
case 'A':{
strcpy(input,optarg);
amp = atof(input);
amp_flag++;
break;
}
case 'a':{
strcpy(annotation,optarg);
std::cout << "Annotation file\t: " << annotation << std::endl;
break;
}
case 'b':{
strcpy(input,optarg);
std::cout << "Input file\t: " << input << std::endl;
if((check = strstr(input,raw)) != NULL){
ff = 2;
}
else if((check = strstr(input,wav)) != NULL){
ff = 1;
}
wave.READ(input,ff,opt);
c_length=length;
break;
}
case 'e':{
strcpy(input,optarg);
std::cout << "Overlapped File\t: " << input << std::endl;
if((check = strstr(input,raw)) != NULL){
ff = 2;
}
else if((check = strstr(input,wav)) != NULL){
ff = 1;
}
wave.READ(input,ff, opt);
break;
}
case 'l':{
strcpy(elabel,optarg);
std::cout << "label file\t: " << elabel << std::endl;
break;
}
case 'r':{
strcpy(input,optarg);
snr = atoi(input);
std::cout << "SNR\t\t: " << snr << "[dB]"<<std::endl;
break;
}
case 'o':{
strcpy(saveid,optarg);
std::cout << "Export file\t: " << saveid << std::endl;
break;
}
case 'O':{
strcpy(annot,optarg);
std::cout << "Export label\t: " << annot << std::endl;
break;
}
case '?':{
useage();
break;
}
default:{
useage();
}
}
}
mix.control(annotation);
//std::cout << "File Length\t: " << c_length << std::endl;
wave.EXPORT(saveid,out,c_length);
mem.clear();
return 0;
}
int main(int argc, char *argv[])
{
HASH *tplh = NULL, *dbh = NULL;
NEOERR *err;
int c, bid = 0, indexid = -1, pgtt;
bool dorecurse = false;
mtc_init(TC_ROOT"blg");
err = mconfig_parse_file(SITE_CONFIG, &g_cfg);
DIE_NOK_MTL(err);
while ( (c=getopt(argc, argv, "b:i:r")) != -1 ) {
switch(c) {
case 'b':
bid = atoi(optarg);
break;
case 'i':
indexid = atoi(optarg);
break;
case 'r':
dorecurse = true;
break;
default:
useage(argv[0]);
}
}
err = ldb_init(&dbh);
DIE_NOK_MTL(err);
err = hash_init(&tplh, hash_str_hash, hash_str_comp);
DIE_NOK_MTL(err);
err = ltpl_parse_file(dbh, NULL, PATH_PAGER, "blog.hdf", tplh);
DIE_NOK_MTL(err);
if (indexid >= 0) {
err = rend_blog_index(dbh, tplh, indexid, &pgtt);
TRACE_NOK(err);
if (indexid > 0 && pgtt > indexid) pgtt = indexid;
if (dorecurse) {
while (pgtt-- > 0) {
err = rend_blog_index(dbh, tplh, pgtt, NULL);
TRACE_NOK(err);
}
}
}
if (bid > 0) {
if (bid > 1)
rend_blog(dbh, tplh, bid-1);
rend_blog(dbh, tplh, bid);
rend_blog(dbh, tplh, bid+1);
}
ldb_destroy(dbh);
ltpl_destroy(tplh);
mconfig_cleanup(&g_cfg);
return 0;
}
int main(int argc,char **argv)
{
WSADATA wsd;
SOCKET sListen,sClient;
int iAddrSize;
HANDLE hThread;
DWORD dwThreadId;
struct sockaddr_in local,client;
ValidateArgs(argc,argv);
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
printf("Failed to load Winsock!\n");
return 1;
}
sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
if(sListen == SOCKET_ERROR)
{
printf("socket() failed:%d\n",WSAGetLastError());
return 1;
}
if(bInterface)
{
local.sin_addr.s_addr = inet_addr(szAddress);
if(local.sin_addr.s_addr==INADDR_NONE)
useage();
}
else
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(iPort);
if(bind(sListen,(struct sockaddr*)&local,sizeof(local)) == SOCKET_ERROR)
{
printf("bind() failed: %d\n",WSAGetLastError());
return 1;
};
listen(sListen,8);
while(1)
{
iAddrSize = sizeof(client);
sClient = accept(sListen,(struct sockaddr*)&client,&iAddrSize);
if(sClient == INVALID_SOCKET)
{
printf("accept() failed: %d\n",WSAGetLastError());
break;
}
printf("Accepted client:%s:%d\n",
inet_ntoa(client.sin_addr),ntohs(client.sin_port));
hThread = CreateThread(NULL,0,ClientThread,(LPVOID)sClient,0,&dwThreadId);
if(hThread == NULL)
{
printf("CreateThread() failed: %d\n",GetLastError());
break;
}
CloseHandle(hThread);
}
printf("close sock\n\n");
closesocket(sListen);
WSACleanup();
return 0;
}
int
main(int argc, char *argv[])
{
char *audio_device;
char *output_file;
char *input_file;
int audio_fd;
size_t buffer_size;
audio_device_t audio_dev;
audio_info_t audio_if;
u_int sample_rate;
u_int channels;
u_int mode;
u_int encoding;
int flags;
int use_duplex;
int use_nonblock;
int use_poll;
int use_select;
int use_bufinfo;
int verbose;
int loops;
const char *errstr;
int ch;
extern char *optarg;
extern int optind;
audio_device = "/dev/audio";
input_file = NULL;
output_file = NULL;
audio_fd = -1;
buffer_size = 8192;
sample_rate = 48000;
channels = 2;
encoding = 0;
loops = 64;
use_nonblock = 0;
use_select = 0;
use_poll = 0;
use_bufinfo = 0;
use_duplex = 0;
verbose = 0;
while ((ch = getopt(argc, argv, "b:c:e:f:i:l:o:r:dnpsv")) != -1) {
switch (ch) {
case 'b':
buffer_size = (size_t)strtonum(optarg, 32, 65536, &errstr);
if (errstr != NULL)
errx(1, "could not grok buffer_size: %s", errstr);
break;
case 'c':
channels = (u_int)strtonum(optarg, 1, 2, &errstr);
if (errstr != NULL)
errx(1, "could not grok channels: %s", errstr);
break;
case 'd':
use_duplex = 1;
break;
case 'e':
encoding = (u_int)strtonum(optarg, 0, 24, &errstr);
if (errstr != NULL)
errx(1, "could not grok encoding: %s", errstr);
break;
case 'f':
audio_device = optarg;
break;
case 'i':
input_file = optarg;
break;
case 'l':
loops = (int)strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL)
errx(1, "could not grok loops: %s", errstr);
break;
case 'n':
use_bufinfo = 1;
break;
case 'o':
output_file = optarg;
break;
case 'p':
use_poll = 1;
use_nonblock = 1;
break;
case 'r':
sample_rate = (u_int)strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL)
errx(1, "could not grok sample_rate: %s", errstr);
break;
case 's':
use_select = 1;
use_nonblock = 1;
break;
case 'v':
verbose = 1;
break;
default:
useage();
exit(1);
break;
}
}
argc -= optind;
argv += optind;
if (use_select + use_poll + use_bufinfo > 1)
errx(1, "can only use one of select, poll or buffer info");
if ((input_file == NULL) && (output_file == NULL))
errx(1, "no input or output file specified");
if ((input_file != NULL) && (output_file != NULL))
use_duplex = 1;
mode = 0;
flags = 0;
if (output_file != NULL) {
mode |= AUMODE_RECORD;
flags = O_RDONLY;
}
if (input_file != NULL) {
mode |= AUMODE_PLAY;
flags = O_WRONLY;
}
if (use_duplex)
flags = O_RDWR;
if (use_nonblock)
flags |= O_NONBLOCK;
if ((audio_fd = open(audio_device, flags)) < 0)
err(1, "open %s", audio_device);
if (audio_set_duplex(audio_fd, audio_device, use_duplex))
errx(1, "could not set duplex mode");
if (audio_set_info(audio_fd, mode, encoding, sample_rate, channels,
&buffer_size))
errx(1, "could not initialize audio device");
if (verbose) {
AUDIO_INITINFO(&audio_if);
if (ioctl(audio_fd, AUDIO_GETINFO, &audio_if) < 0)
err(1, "AUDIO_GETINFO");
if (ioctl(audio_fd, AUDIO_GETDEV, &audio_dev) < 0)
err(1, "AUDIO_GETDEV");
warnx("audio device: %s: %s ver %s, config: %s", audio_device,
audio_dev.name, audio_dev.version, audio_dev.config);
warnx("blocksize: %u", audio_if.blocksize);
warnx("lowat: %u", audio_if.lowat);
warnx("hiwat: %u", audio_if.hiwat);
warnx("play.buffer_size: %u", audio_if.play.buffer_size);
warnx("record.buffer_size: %u", audio_if.record.buffer_size);
if (output_file != NULL)
warnx("output file: %s", output_file);
if (input_file != NULL)
warnx("input file: %s", input_file);
warnx("flags: %d", flags);
warnx("mode: %u", mode);
warnx("encoding: %u", encoding);
warnx("sample_rate: %u", sample_rate);
warnx("channels: %u", channels);
warnx("use_select: %d", use_select);
warnx("use_poll: %d", use_poll);
warnx("use_bufinfo: %d", use_bufinfo);
warnx("use_duplex: %d", use_duplex);
warnx("buffer_size: %lu", (unsigned long)buffer_size);
}
/* need to trigger recording in duplex mode */
if (use_duplex && (mode & AUMODE_RECORD))
if (audio_trigger_record(audio_fd))
exit(1);
if (audio_do_test(audio_fd, buffer_size, input_file, output_file,
mode, use_poll, use_select, use_bufinfo, loops, verbose))
exit(1);
if (verbose)
warnx("test completed");
if (audio_fd >= 0)
close(audio_fd);
exit(0);
}
int main(int argc, char** argv)
{
struct sockaddr_in servaddr,cliaddr;
fd_set readset, tempset;
int maxfd, flags;
int srvsock, peersock, j, result, result1, sent, len;
struct timeval tv;
char buffer[MAX_BUFFER_SIZE+1];
if(argc <2)
{
useage(argv[0]);
exit(1);
}
if ((srvsock = socket(AF_INET,SOCK_STREAM, 0 )) < 0 )
{
printf( " create socket error!\n " );
exit( 1 );
}
/* if (setsockopt(servfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
{
perror("setsockopt");
exit(1);
}
*/
bzero( & servaddr, sizeof (servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[1]));
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(srvsock,( struct sockaddr * ) & servaddr, sizeof (servaddr)) < 0 )
{
printf( " bind to port %d failure!\n " ,servaddr.sin_port);
exit( 1 );
}
int sock_lis = listen(srvsock,0);
if (sock_lis < 0 )
{
printf( " call listen failure!\n " );
exit( 1 );
}
FD_ZERO(&readset);
FD_SET(srvsock, &readset);
maxfd = srvsock;
do {
memcpy(&tempset, &readset, sizeof(tempset));
tv.tv_sec = 30;
tv.tv_usec = 0;
result = select(maxfd + 1, &tempset, NULL, NULL, &tv);
if (result == 0) {
printf("\nselect() timed out!\n");
}
else if (result < 0 && errno != EINTR) {
printf("Error in select(): %s\n", strerror(errno));
}
else if (result > 0) {
if (FD_ISSET(srvsock, &tempset)) {
len = sizeof(cliaddr);
peersock = accept(srvsock,(struct sockaddr *) &cliaddr, &len);
if (peersock < 0) {
printf("Error in accept(): %s\n", strerror(errno));
}
else {
threadnum++;
printf("%d connections are built!\n",threadnum);
FD_SET(peersock, &readset);
maxfd = (maxfd < peersock)?peersock:maxfd;
}
FD_CLR(srvsock, &tempset);
}
for (j=0; j<maxfd+1; j++) {
if (FD_ISSET(j, &tempset)) {
do {
bzero(buffer,sizeof(buffer));
result = recv(j, buffer, MAX_BUFFER_SIZE, 0);
} while (result == -1 && errno == EINTR);
if (result > 0) {
// buffer[result] = 0;
// printf("Echoing: %s\n", buffer);
printf("%s", buffer);
sent = 0;
do {
result1 = send(j, buffer+sent, result-sent, MSG_NOSIGNAL);
if (result1 > 0)
sent += result1;
else if (result1 < 0 && errno != EINTR);
break;
} while (result > sent);
}
else if (result == 0) {
close(j);
FD_CLR(j, &readset);
threadnum--;
}
else {
printf("Error in recv(): %s\n", strerror(errno));
}
} // end if (FD_ISSET(j, &tempset))
} // end for (j=0;...)
} // end else if (result > 0)
} while (1);
return 0;
}
/*start_address/size does not include oob
*/
int main(int argc, char **argv)
{
uint32_t start_address,size;
char *nand_image;
uint32_t pagenumber,pages;
int nand_fd;
uint32_t i,j;
uint8_t page_data[BB_NAND_PAGE_SIZE+BB_NAND_OOB_SIZE];
uint8_t ecc_data[3];
if (argc!=4)
{
useage();
exit(1);
}
nand_image = argv[1];
start_address = strtol(argv[2],NULL,0);
size = strtol(argv[3],NULL,0);
nand_fd = open(nand_image,O_RDWR);
if (nand_fd<0)
{
printf("Can not open nand image %s \n",nand_image);
exit(1);
}
if (start_address>=BB_NAND_SIZE)
{
printf("start_address can no be more than 0x%x \n",BB_NAND_SIZE);
exit(1);
}
if ((start_address%BB_NAND_PAGE_SIZE)!=0)
{
printf("start_address should be aligned to page boundary \n");
exit(1);
}
if (size==0)
{
printf("size can no be zero \n");
exit(1);
}
if ((size%BB_NAND_PAGE_SIZE)!=0)
{
printf("size should be aligned to page boundary \n");
exit(1);
}
pagenumber = start_address/BB_NAND_PAGE_SIZE;
pages = size/BB_NAND_PAGE_SIZE;
for (i=0;i<pages;i++)
{
lseek(nand_fd,pagenumber*(BB_NAND_PAGE_SIZE+BB_NAND_OOB_SIZE),SEEK_SET);
read(nand_fd,page_data,BB_NAND_PAGE_SIZE+BB_NAND_OOB_SIZE);
for (j=0;j<BB_NAND_PAGE_SIZE/256;j++)
{
nand_calculate_ecc(page_data+j*256,ecc_data);
memcpy(page_data+BB_NAND_PAGE_SIZE+BB_NAND_ECC_OFFSET+j*3,ecc_data,3);
}
lseek(nand_fd,pagenumber*(BB_NAND_PAGE_SIZE+BB_NAND_OOB_SIZE),SEEK_SET);
write(nand_fd,page_data,BB_NAND_PAGE_SIZE+BB_NAND_OOB_SIZE);
pagenumber++;
}
close(nand_fd);
return (1);
}
int main(int argc, char** argv)
{
int servfd;
int new_f =0;
int yes=1;
char buf[BUFFER_SIZE];
struct sockaddr_in servaddr,cliaddr;
if(argc <2)
{
useage(argv[0]);
exit(1);
}
if ((servfd = socket(AF_INET,SOCK_STREAM, 0 )) < 0 )
{
printf( " create socket error!\n " );
exit( 1 );
}
if (setsockopt(servfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
bzero( & servaddr, sizeof (servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[1]));
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(servfd,( struct sockaddr * ) & servaddr, sizeof (servaddr)) < 0 )
{
printf( " bind to port %d failure!\n " ,servaddr.sin_port);
exit( 1 );
}
int sock_lis = listen(servfd,0);
if (sock_lis < 0 )
{
printf( " call listen failure!\n " );
exit( 1 );
}
fd_set f_read;
// fd_set f_write;
int max_con;
struct timeval tv;
int i;
con_num = 0;
max_con = servfd;
for(i =0;i<SETNUM;i++)
{
fd_ary[i]= 0;
}
while(1)
{
FD_ZERO(&f_read);
FD_SET(servfd, &f_read);
tv.tv_sec =30;
tv.tv_usec =0;
for(i =0;i<SETNUM;i++)
{
if(fd_ary[i] != 0)
{
//printf("fd_ary[i]:%d\n",fd_ary[i]);
FD_SET(fd_ary[i],&f_read);
}
}
int ret = select(max_con+1,&f_read,NULL,NULL,&tv);
if(ret < 0 && errno !=EINTR)
{
perror("select");
// break;
}
else if(ret == 0)
{
printf("select() timed out!\n");
continue;
}
else if(ret >0){
if(FD_ISSET(servfd,&f_read))
{
socklen_t length = sizeof (cliaddr);
new_f = accept(servfd,( struct sockaddr * ) & cliaddr, & length);
if(new_f <0)
{
perror("accept");
//continue;
}
else if(new_f >0) //一定要这样写，不然下面的new_f依然会添加到fd_ary中
{
printf( " from client,IP:%s,Port:%d\n " ,inet_ntoa(cliaddr.sin_addr),ntohs(cliaddr.sin_port));
FD_CLR(servfd,&f_read);
if(con_num <SETNUM)
{
for(i=0;i<SETNUM;i++)
{
if(fd_ary[i]== 0)
{
fd_ary[i] =new_f;
break;
}
}
con_num++;
if(new_f > max_con)
{
max_con = new_f;
}
}
else
{
printf("max connections arrive, exit\n");
send(new_f, "bye", 4, 0);
close(new_f);
break;
}
}
}
/* if(con_num <SETNUM)
{
for(i=0;i<SETNUM;i++)
{
if(fd_ary[i]== 0)
{
fd_ary[i] =new_f;
break;
}
}
con_num++;
if(new_f > max_con)
{
max_con = new_f;
}
}
else
{
printf("max connections arrive, exit\n");
send(new_f, "bye", 4, 0);
close(new_f);
break;
}
*/
for(i =0;i <SETNUM;i++)
{
if(FD_ISSET(fd_ary[i],&f_read))
{
while(1)
{
ret = recv(fd_ary[i],buf,BUFFER_SIZE,0);
if(ret <=0)
{
printf("client %d is out!\n",fd_ary[i]);
close(fd_ary[i]);
FD_CLR(fd_ary[i],&f_read);
fd_ary[i] = 0;
con_num--;
break;
}
else if(ret >0)
{
action_after_recv(buf,ntohs(cliaddr.sin_port));
send(fd_ary[i],buf,BUFFER_SIZE, 0 );
printf("sent to client::%s\n",buf);
break; //这个break超级超级重要，不然就一直会阻塞在这个while循环里
}
} //end while(1)
}
}
}
}
for(i =0;i<SETNUM;i++)
{
if(fd_ary[i]!= 0)
{
close(fd_ary[i]);
}
}
exit(0);
}
int
main ( int argc, char *argv[] )
{
int i;
//init ListHead
list_init(&P2PCB_head);
list_init(&downloading_piece_head);
//init mutex
pthread_mutexattr_t mutex_attr;
pthread_mutexattr_settype(&mutex_attr,PTHREAD_MUTEX_RECURSIVE_NP);
pthread_mutex_init(&P2P_mutex,&mutex_attr);
pthread_mutex_init(&download_mutex,&mutex_attr);
pthread_mutex_init(&firstReq_mutex,&mutex_attr);
pthread_mutex_init(&pieceCounter_mutex,&mutex_attr);
// <-- deal with argument -->
globalArgs.port = 6881;
globalArgs.isseed = 0;
globalArgs.torrentpath = NULL;
int opt;
while(opt = getopt(argc, argv, optstring), opt != -1){
switch(opt){
case 'p':
{
globalArgs.port = atoi(optarg);
break;
}
case 'i':
{
globalArgs.isseed = atoi(optarg);
break;
}
case 'v':
{
globalArgs.verbose = true;
break;
}
case 'h':
{
useage();
exit(0);
break;
}
case '?':
{
useage();
exit(0);
break;
}
default:
{
assert(false && "some amazing thing happen when parser argument");
break;
}
}
}
globalArgs.torrentpath = argv[argc - 1];
// <-- end -->
#ifdef DEBUG
printf("isseed:%d\n", globalArgs.isseed);
printf("port:%d\n", globalArgs.port);
printf("torrentpath:%s\n", globalArgs.torrentpath);
printf("verbose:%s\n", (globalArgs.verbose)?"true":"false");
#endif
// <-- set value of globalInfo -->
init_peer_id(globalInfo.g_my_id);
globalInfo.g_peer_port = globalArgs.port;
globalInfo.g_torrentmeta = parsetorrentfile(globalArgs.torrentpath);
if (globalInfo.g_torrentmeta == NULL){
printf("Error when parsing torrent file\n");
return -1;
}
for (i = 0; i < globalInfo.g_torrentmeta->filenum; i++){
globalInfo.g_torrentmeta->flist[i].fp = createfile(globalInfo.g_torrentmeta->flist[i].filename, globalInfo.g_torrentmeta->flist[i].size);
}
globalInfo.bitfield = gen_bitfield(globalInfo.g_torrentmeta->pieces, globalInfo.g_torrentmeta->piece_len, globalInfo.g_torrentmeta->num_pieces);
#ifdef DEBUG
printf("bitfield:");
for (i = 0; i <= globalInfo.g_torrentmeta->num_pieces / 8; i++)
printf("%X ", globalInfo.bitfield[i]);
printf("\n");
#endif
//set piece_counter for "least first"
piece_counter = (int *)malloc(sizeof(int)*globalInfo.g_torrentmeta->num_pieces);
memset(piece_counter,0,sizeof(int)*globalInfo.g_torrentmeta->num_pieces);
// <-- end -->
// <-- create socket listen to port -->
listenfd = make_listen_port(globalInfo.g_peer_port);
if (listenfd == 0){
printf("Error when create socket for binding:%s\n", strerror(errno));
exit(-1);
}
pthread_t p_daemon;
if (pthread_create(&p_daemon, NULL, daemon_listen, (void *)listenfd) != 0){
int tmp = errno;
printf("Error when create daemon thread: %s\n", strerror(tmp));
return -1;
}
pthread_t p_speed;
if (pthread_create(&p_speed, NULL, show_speed, NULL) != 0){
int tmp = errno;
printf("Error when create show_speed thread: %s\n", strerror(tmp));
return -1;
}
announce_url_t *announce_info = parse_announce_url(globalInfo.g_torrentmeta->announce);
if (globalArgs.verbose == true){
printf("host: %s:%d\n", announce_info->hostname, announce_info->port);
}
struct hostent *tracker_hostent = gethostbyname(announce_info->hostname);
if (tracker_hostent == NULL){
printf("Error when get tracker host\n");
return -1;
}
strcpy(globalInfo.g_tracker_ip, inet_ntoa(*((struct in_addr *)tracker_hostent->h_addr_list[0])));
globalInfo.g_tracker_port = announce_info->port;
free(announce_info);
announce_info = NULL;
// set the action after recv ctrl-c
signal(SIGINT, client_shutdown);
signal(SIGPIPE, SIG_IGN);
int event_value = BT_STARTED;
while(true){
int sockfd = connect_to_host(globalInfo.g_tracker_ip, globalInfo.g_tracker_port);
#ifdef DEBUG
printf("Sending request to tracker\n");
#endif
int request_len = 0;
char *request = make_tracker_request(&globalInfo, event_value, &request_len);
event_value = -1;
#ifdef DEBUG
printf("%s", request);
#endif
if (send(sockfd, request, request_len, 0) == -1){
int tmp = errno;
printf("%s\n", strerror(tmp));
// error when connect to tracker, wait some time and try again
sleep(5);
close(sockfd);
free(request);
continue;
}
tracker_response *tr = preprocess_tracker_response(sockfd);
close(sockfd);
globalInfo.g_tracker_response = get_tracker_data(tr->data, tr->size);
free(tr->data);
free(tr);
#ifdef DEBUG
printf("Num Peers: %d\n", globalInfo.g_tracker_response->numpeers);
for (i = 0; i < globalInfo.g_tracker_response->numpeers; i++){
printf("Peer ip: %s:%d\n", globalInfo.g_tracker_response->peers[i].ip, globalInfo.g_tracker_response->peers[i].port);
}
#endif
for (i = 0; i < globalInfo.g_tracker_response->numpeers; i++){
if (!exist_ip(globalInfo.g_tracker_response->peers[i].ip)){
pthread_t tid;
p2p_thread_param *param = (p2p_thread_param *)malloc(sizeof(p2p_thread_param));
param->is_connecter = 1;
param->port = globalInfo.g_tracker_response->peers[i].port;
strcpy(param->ip, globalInfo.g_tracker_response->peers[i].ip);
if (pthread_create(&tid, NULL, process_p2p_conn, param) != 0){
printf("Error when create thread to connect peer\n");
} else {
printf("Success create thread to connect peer %s\n", globalInfo.g_tracker_response->peers[i].ip);
}
}
}
printf("sleep %d seconds\n", globalInfo.g_tracker_response->interval);
sleep(globalInfo.g_tracker_response->interval);
}
return EXIT_SUCCESS;
} /* ---------- end of function main ---------- */
int main(int argc, char **argv) {
IMAGE *I;
int i;
int ac, nargs ;
char **av ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: nmovie.c,v 1.29.2.1 2011/09/28 21:14:00 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
XInit(&argc,&argv);
if (argc<2)
useage();
for (i=1;i<argc;i++) {
I = ImageReadHeader(argv[i]);
if (!I)
ErrorExit(ERROR_NOFILE,
"%s: could not read image file %s\n",Progname,argv[i]);
switch (I->pixel_format) {
case PFBYTE:
case PFSHORT:
case PFFLOAT:
nocolor = 1 ;
break ;
default:
break ;
}
if ((rows && (I->orows != rows)) || (cols && (I->ocols != cols))) {
ErrorPrintf
(ERROR_BADFILE,
"%s: image %s dimensions (%d x %d) "
"don't match first image (%d x %d)",
Progname, argv[i],I->ocols, I->orows, cols, rows) ;
ImageFree(&I) ;
memmove(&argv[i], &argv[i+1], argc-i) ;
i-- ;
argc-- ;
continue ;
}
nm_pfmt = MAX(nm_pfmt,I->pixel_format);
rows = MAX(rows,I->orows);
cols = MAX(cols,I->ocols);
ImageFree(&I);
}
nframes = argc-1;
XSetupDisplay(nframes);
MakeDispNames(argc,argv);
ConvertImages(nframes,argv);
XtMapWidget(toplevel);
XtAppMainLoop(xi.context);
return 0; /* Make -Wall happy! */
}
