void rrawbin3D(struct data *d,int dataorder,int type,int precision)
{
char indir[MAXPATHLEN];
int datamode;
#ifdef DEBUG
struct timeval tp;
double t1,t2;
int rtn;
fprintf(stdout,"\n%s: %s()\n",__FILE__,__FUNCTION__);
fprintf(stdout," Reading raw 3D data\n");
rtn=gettimeofday(&tp, NULL);
t1=(double)tp.tv_sec+(1.e-6)*tp.tv_usec;
fflush(stdout);
#endif
/* Check that type is valid */
if (type != CX) {
fprintf(stderr,"\n%s: %s()\n",__FILE__,__FUNCTION__);
fprintf(stderr," Invalid 3rd argument %s(*,*,'type',*)\n",__FUNCTION__);
fflush(stderr);
return;
}
datamode=FID;
/* If FT has been done flag it as IMAGE */
if ((d->dimstatus[0] & FFT) || (d->dimstatus[1] & FFT) || (d->dimstatus[2] & FFT)) datamode=IMAGE;
/* Set up input directory (indir) according to type */
switch(datamode) {
case FID: strcpy(indir,"raw"); break;
default: strcpy(indir,"recon"); break;
}
strcat(indir,"CX");
switch(dataorder) {
case D12: setblock(d,d->nv); strcat(indir,"_D12"); break;
case D3: setblock(d,d->nv2); strcat(indir,"_D3"); break;
}
strcat(indir,".raw");
/* Select input */
if (d->nr>1) get3Draw(d,'i',indir,dataorder);
else get3Draw(d,'s',indir,dataorder);
#ifdef DEBUG
rtn=gettimeofday(&tp, NULL);
t2=(double)tp.tv_sec+(1.e-6)*tp.tv_usec;
fprintf(stdout," Took %f secs\n",t2-t1);
fflush(stdout);
#endif
}
int main(void) {
char buf[BUFSIZE];
int n;
for ( ; ; ) {
fprintf(stderr,"Blocking input on standard input\n");
setblock(STDIN_FILENO);
n = read(STDIN_FILENO,buf,BUFSIZE);
if (n == 0)
break;
if (n > 0)
fprintf(stderr,"Got %d bytes: %.*s\n",n,n,buf);
else
perror("nonblocking error");
fprintf(stderr,"Nonblocking input on standard input\n");
n = 0;
setnonblock(STDIN_FILENO);
while (n <= 0) {
n = read(STDIN_FILENO,buf,BUFSIZE);
if (n > 0)
fprintf(stderr,"Got %d bytes: %.*s\n",n,n,buf);
else
perror("blocking error");
sleep(1);
}
}
return 0;
}
int connect(int sockfd, const struct sockaddr *serv_addr,socklen_t addrlen,int tmo)
{
//#ifndef _WIN32
struct timeval tv;
fd_set wset;
int ret;
if(tmo==0)
return connect(sockfd,serv_addr,addrlen);
return connect(sockfd,serv_addr,addrlen);
/* state=fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, state|O_NONBLOCK );
*/
setnoblock(sockfd);
connect(sockfd,serv_addr,addrlen);
tv.tv_sec=tmo;
tv.tv_usec=0;
FD_ZERO(&wset);
FD_SET(sockfd,&wset);
ret = select(sockfd+1,NULL,&wset,NULL,&tv);
// fcntl(sockfd, F_SETFL, state );
setblock(sockfd);
if(ret<=0)
return -1;
return 0;
/*#else
return connect(sockfd,serv_addr,addrlen);
#endif
*/
};
void mysocket::clear_recvq(int len)
{
if(len<=0)
return;
char *str=(char *)malloc(len);
setnoblock(new_socket);
::recv(new_socket,str,len,0);
setblock(new_socket);
free(str);
}
void
dictinit(char *fname)
{
Stream *fin;
Block *b;
fin = sopen(fname, OREAD);
while(b = getblock(fin)){
setblock(b);
free(b);
}
sclose(fin);
}
void main()
{
char mess[80];
int fd;
int numch;
schedule();
/*pid = fork(); //not needed
if ( pid == 0 )
{
while (1)
{
i++;
if (i % 10000 == 0 ) putc('.',stderr); //child
}
}
else { */
fd = open("/dev/tty",O_RDWR);
setblock(fd,false);
sigemptyset(&sig); /* clear the signal mask */
newhandler.sa_handler = next;
newhandler.sa_mask = sig;
newhandler.sa_flags = 0;
if ( sigaction(SIGALRM,&newhandler,&oldhandler) == -1 )
{
printf("1 - can't install signal handler \n");
exit(-1);
}
while (1)
{
alarm(3);
pause();
switch ( numch = read(fd,mess,80))
{
case -1 :
case 0 :
break;
default:
fprintf(stderr," %d <%s>\n",numch,mess);
}
fprintf(stderr," in parent\n");
}
}
void main() {
char mess[80]; //user input message stored in this array
int fd;
int numch;
fd = open("/dev/tty",O_RDWR);
setblock(fd,false);
sigemptyset(&sig); /* clear the signal mask */
newhandler.sa_handler = next; /*go to the next() function*/
newhandler.sa_mask = sig;
newhandler.sa_flags = 0;
if ( sigaction(SIGALRM,&newhandler,&oldhandler) == -1 ) {
printf("1 - can't install signal handler \n");
exit(-1);
}
while (1) {
alarm(3);
pause();
switch ( numch = read(fd,mess,80)) {
case -1 :
case 0 : break;
default : mess[numch-1] = '\0'; //put null character at end of string
//fprintf(stderr," %d <%s>\n",numch,mess);
pid[i] = fork();
if ( pid[i] == 0 ) {
strcpy(path,"./");
strcat(path,mess);
execl(path,mess,NULL);
}
else {
i++;
numProcess++;
}
}
fprintf(stderr,"This is the parent process.\n");
fprintf(stderr,"Enter process name to execute.\n\n");
}
}
int himd_writestream_write(struct himd_writestream * stream, struct blockinfo * audioblock, struct himderrinfo *status)
{
unsigned char data[HIMD_BLOCKINFO_SIZE];
g_return_val_if_fail(stream != NULL, -1);
g_return_val_if_fail(audioblock != NULL, -1);
status = status;
stream = stream;
// serialize the block descriptor
setblock(audioblock, data);
// write the block descriptor to the current position in the stream at 'stream->curblockno'
if(fwrite(data, 16384, 1, stream->atdata) != 1)
{
perror("fwrite block\n");
fprintf(stderr, "Error writing block to position %d\n", stream->curblockno);
return -1;
}
return 0;
}
int msocketx::connect(const char* pszip,unsigned short usport,bool bblock)
{
if (pszip == NULL)
return -1;
if (!isvalid())
{
if (! create(SOCK_STREAM,0))
return -1;
}
setblock(bblock);
sockaddr_in addr = {0};
addr.sin_port = htons(usport);
addr.sin_addr.s_addr = inet_addr(pszip);
addr.sin_family = AF_INET;
return ::connect(m_sock,(sockaddr*)&addr,sizeof(addr));
}
static rval_t re_connect(conn_t* conn){
rval_t rval;
rval.err = 0;
if((conn->sockfd = socket(PF_INET,SOCK_STREAM,0))<0){
debug_err(" create socket failed! errno[%d]\n", errno);
rval.err = errno;
return rval;
}
sock_general_init(conn->sockfd);
rval.v = connect(conn->sockfd,(struct sockaddr *)&conn->addr, sizeof(struct sockaddr));
if(rval.v == -1){
rval.err = errno;
close(conn->sockfd);
}
setblock(conn->sockfd, 0); //not block
return rval;
}
int main(){
int fd;
int numch;
fd = open("/dev/tty",O_RDWR); // Opens the keyboard.
setblock(fd,false); // Read won't block.
sigemptyset(&sig); /* clear the signal mask */
newhandler.sa_handler = monitor; // Designates the handler.
newhandler.sa_mask = sig;
newhandler.sa_flags = 0;
if ( sigaction(SIGALRM,&newhandler,&oldhandler) == -1 ){
printf("1 - can't install signal handler \n");
exit(-1);
}
while (1) {
printf("\n**** In parent. ***** \n\n");
alarm(1);
pause();
switch ( numch = read(fd, process, 256)) {
case -1 :
case 0 :
break;
default:
process[numch-1] = '\0';
scheduler();
}
}
return 0;
}
/*
* Initialize a cylinder group.
*/
void
initcg(int cylno, time_t utime)
{
long blkno, start;
uint i, j, d, dlower, dupper;
ufs2_daddr_t cbase, dmax;
struct ufs1_dinode *dp1;
struct ufs2_dinode *dp2;
struct csum *cs;
/*
* Determine block bounds for cylinder group.
* Allow space for super block summary information in first
* cylinder group.
*/
cbase = cgbase(&sblock, cylno);
dmax = cbase + sblock.fs_fpg;
if (dmax > sblock.fs_size)
dmax = sblock.fs_size;
dlower = cgsblock(&sblock, cylno) - cbase;
dupper = cgdmin(&sblock, cylno) - cbase;
if (cylno == 0)
dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
cs = &fscs[cylno];
memset(&acg, 0, sblock.fs_cgsize);
acg.cg_time = utime;
acg.cg_magic = CG_MAGIC;
acg.cg_cgx = cylno;
acg.cg_niblk = sblock.fs_ipg;
acg.cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ?
sblock.fs_ipg : 2 * INOPB(&sblock);
acg.cg_ndblk = dmax - cbase;
if (sblock.fs_contigsumsize > 0)
acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
start = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
if (Oflag == 2) {
acg.cg_iusedoff = start;
} else {
acg.cg_old_ncyl = sblock.fs_old_cpg;
acg.cg_old_time = acg.cg_time;
acg.cg_time = 0;
acg.cg_old_niblk = acg.cg_niblk;
acg.cg_niblk = 0;
acg.cg_initediblk = 0;
acg.cg_old_btotoff = start;
acg.cg_old_boff = acg.cg_old_btotoff +
sblock.fs_old_cpg * sizeof(int32_t);
acg.cg_iusedoff = acg.cg_old_boff +
sblock.fs_old_cpg * sizeof(u_int16_t);
}
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
if (sblock.fs_contigsumsize > 0) {
acg.cg_clustersumoff =
roundup(acg.cg_nextfreeoff, sizeof(u_int32_t));
acg.cg_clustersumoff -= sizeof(u_int32_t);
acg.cg_clusteroff = acg.cg_clustersumoff +
(sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
acg.cg_nextfreeoff = acg.cg_clusteroff +
howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
}
if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
printf("Panic: cylinder group too big\n");
exit(37);
}
acg.cg_cs.cs_nifree += sblock.fs_ipg;
if (cylno == 0)
for (i = 0; i < (long)ROOTINO; i++) {
setbit(cg_inosused(&acg), i);
acg.cg_cs.cs_nifree--;
}
if (cylno > 0) {
/*
* In cylno 0, beginning space is reserved
* for boot and super blocks.
*/
for (d = 0; d < dlower; d += sblock.fs_frag) {
blkno = d / sblock.fs_frag;
setblock(&sblock, cg_blksfree(&acg), blkno);
if (sblock.fs_contigsumsize > 0)
setbit(cg_clustersfree(&acg), blkno);
acg.cg_cs.cs_nbfree++;
}
}
if ((i = dupper % sblock.fs_frag)) {
acg.cg_frsum[sblock.fs_frag - i]++;
for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
setbit(cg_blksfree(&acg), dupper);
acg.cg_cs.cs_nffree++;
}
}
for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;
d += sblock.fs_frag) {
blkno = d / sblock.fs_frag;
setblock(&sblock, cg_blksfree(&acg), blkno);
if (sblock.fs_contigsumsize > 0)
setbit(cg_clustersfree(&acg), blkno);
acg.cg_cs.cs_nbfree++;
}
if (d < acg.cg_ndblk) {
acg.cg_frsum[acg.cg_ndblk - d]++;
for (; d < acg.cg_ndblk; d++) {
setbit(cg_blksfree(&acg), d);
acg.cg_cs.cs_nffree++;
}
}
if (sblock.fs_contigsumsize > 0) {
int32_t *sump = cg_clustersum(&acg);
u_char *mapp = cg_clustersfree(&acg);
int map = *mapp++;
int bit = 1;
int run = 0;
for (i = 0; i < acg.cg_nclusterblks; i++) {
if ((map & bit) != 0)
run++;
else if (run != 0) {
if (run > sblock.fs_contigsumsize)
run = sblock.fs_contigsumsize;
sump[run]++;
run = 0;
}
if ((i & (CHAR_BIT - 1)) != CHAR_BIT - 1)
bit <<= 1;
else {
map = *mapp++;
bit = 1;
}
}
if (run != 0) {
if (run > sblock.fs_contigsumsize)
run = sblock.fs_contigsumsize;
sump[run]++;
}
}
*cs = acg.cg_cs;
/*
* Write out the duplicate super block, the cylinder group map
* and two blocks worth of inodes in a single write.
*/
start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE;
bcopy((char *)&acg, &iobuf[start], sblock.fs_cgsize);
start += sblock.fs_bsize;
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
dp2 = (struct ufs2_dinode *)(&iobuf[start]);
for (i = 0; i < acg.cg_initediblk; i++) {
if (sblock.fs_magic == FS_UFS1_MAGIC) {
dp1->di_gen = newfs_random();
dp1++;
} else {
dp2->di_gen = newfs_random();
dp2++;
}
}
wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf);
/*
* For the old file system, we have to initialize all the inodes.
*/
if (Oflag == 1) {
for (i = 2 * sblock.fs_frag;
i < sblock.fs_ipg / INOPF(&sblock);
i += sblock.fs_frag) {
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
for (j = 0; j < INOPB(&sblock); j++) {
dp1->di_gen = newfs_random();
dp1++;
}
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
sblock.fs_bsize, &iobuf[start]);
}
}
}
int
crypt_file( char *source, char *dest )
{
char *s;
int c;
int iRow;
int iCol;
FILE *infile;
FILE *outfile;
while (!key_defined)
crypt_key( KEY_IMMEDIATE, "?" );
if ((infile = fopen( source, "rb" )) == NULL)
{
fprintf( stderr, "Can not open %s for reading.\n", source);
return 1;
}
if ((outfile = fopen( dest, "wb" )) == NULL)
{
fprintf( stderr, "Can not open %s for writing.\n", dest);
fclose( infile );
return 1;
}
if ( encrypt_or_decrypt == DECRYPTION_SELECT )
{
c = rows;
rows = columns;
columns = c;
}
trans.max = rows * columns;
while (trans.left=fread (trans.data, sizeof (char), trans.max, infile))
{
trans.next = trans.data;
while (setblock() != 0)
for(iCol=0; iCol<trans.column; iCol++)
for(iRow=0; iRow<trans.row ;iRow++)
{
c = *((trans.start)+iCol+iRow*(trans.column));
if (fputc(c, outfile) == EOF)
{
fprintf(stderr, "Could not write to output file %s\n", dest);
fclose( infile );
fclose( outfile );
return 1;
}
}
if(trans.left) /* if less than 3 bytes, reverse */
for(iCol=0; iCol<trans.left; iCol++)
{
c = *(trans.start + trans.left - 1 - iCol);
if (fputc(c, outfile) == EOF)
{
fprintf(stderr, "Could not write to output file %s\n", dest);
fclose( infile );
fclose( outfile );
return 1;
}
}
}
if ( encrypt_or_decrypt == DECRYPTION_SELECT )
{
c = rows;
rows = columns;
columns = c;
}
fclose( infile );
fclose( outfile );
return 0;
}
/*
* Initialize a cylinder group.
*/
void
initcg(int cylno, time_t utime)
{
int i, j, d, dlower, dupper, blkno, start;
daddr64_t cbase, dmax;
struct ufs1_dinode *dp1;
struct ufs2_dinode *dp2;
struct csum *cs;
/*
* Determine block bounds for cylinder group. Allow space for
* super block summary information in first cylinder group.
*/
cbase = cgbase(&sblock, cylno);
dmax = cbase + sblock.fs_fpg;
if (dmax > sblock.fs_size)
dmax = sblock.fs_size;
if (fsbtodb(&sblock, cgsblock(&sblock, cylno)) + iobufsize / sectorsize
> fssize)
errx(40, "inode table does not fit in cylinder group");
dlower = cgsblock(&sblock, cylno) - cbase;
dupper = cgdmin(&sblock, cylno) - cbase;
if (cylno == 0)
dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
cs = &fscs[cylno];
memset(&acg, 0, sblock.fs_cgsize);
acg.cg_ffs2_time = utime;
acg.cg_magic = CG_MAGIC;
acg.cg_cgx = cylno;
acg.cg_ffs2_niblk = sblock.fs_ipg;
acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));
acg.cg_ndblk = dmax - cbase;
start = sizeof(struct cg);
if (Oflag <= 1) {
/* Hack to maintain compatibility with old fsck. */
if (cylno == sblock.fs_ncg - 1)
acg.cg_ncyl = 0;
else
acg.cg_ncyl = sblock.fs_cpg;
acg.cg_time = acg.cg_ffs2_time;
acg.cg_ffs2_time = 0;
acg.cg_niblk = acg.cg_ffs2_niblk;
acg.cg_ffs2_niblk = 0;
acg.cg_initediblk = 0;
acg.cg_btotoff = start;
acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(int32_t);
acg.cg_iusedoff = acg.cg_boff +
sblock.fs_cpg * sizeof(u_int16_t);
} else {
acg.cg_iusedoff = start;
}
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
if (acg.cg_nextfreeoff > sblock.fs_cgsize)
errx(37, "panic: cylinder group too big: %d > %d",
acg.cg_nextfreeoff, sblock.fs_cgsize);
acg.cg_cs.cs_nifree += sblock.fs_ipg;
if (cylno == 0) {
for (i = 0; i < ROOTINO; i++) {
setbit(cg_inosused(&acg), i);
acg.cg_cs.cs_nifree--;
}
}
if (cylno > 0) {
/*
* In cylno 0, space is reserved for boot and super blocks.
*/
for (d = 0; d < dlower; d += sblock.fs_frag) {
blkno = d / sblock.fs_frag;
setblock(&sblock, cg_blksfree(&acg), blkno);
acg.cg_cs.cs_nbfree++;
if (Oflag <= 1) {
cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
[cbtorpos(&sblock, d)]++;
}
}
}
if ((i = dupper % sblock.fs_frag)) {
acg.cg_frsum[sblock.fs_frag - i]++;
for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
setbit(cg_blksfree(&acg), dupper);
acg.cg_cs.cs_nffree++;
}
}
for (d = dupper;
d + sblock.fs_frag <= acg.cg_ndblk;
d += sblock.fs_frag) {
blkno = d / sblock.fs_frag;
setblock(&sblock, cg_blksfree(&acg), blkno);
acg.cg_cs.cs_nbfree++;
if (Oflag <= 1) {
cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
[cbtorpos(&sblock, d)]++;
}
}
if (d < acg.cg_ndblk) {
acg.cg_frsum[acg.cg_ndblk - d]++;
for (; d < acg.cg_ndblk; d++) {
setbit(cg_blksfree(&acg), d);
acg.cg_cs.cs_nffree++;
}
}
*cs = acg.cg_cs;
/*
* Write out the duplicate superblock, the cylinder group map
* and two blocks worth of inodes in a single write.
*/
start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE;
bcopy((char *)&acg, &iobuf[start], sblock.fs_cgsize);
start += sblock.fs_bsize;
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
dp2 = (struct ufs2_dinode *)(&iobuf[start]);
for (i = MIN(sblock.fs_ipg, 2 * INOPB(&sblock)); i != 0; i--) {
if (sblock.fs_magic == FS_UFS1_MAGIC) {
dp1->di_gen = (u_int32_t)arc4random();
dp1++;
} else {
dp2->di_gen = (u_int32_t)arc4random();
dp2++;
}
}
wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf);
if (Oflag <= 1) {
/* Initialize inodes for FFS1. */
for (i = 2 * sblock.fs_frag;
i < sblock.fs_ipg / INOPF(&sblock);
i += sblock.fs_frag) {
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
for (j = 0; j < INOPB(&sblock); j++) {
dp1->di_gen = (u_int32_t)arc4random();
dp1++;
}
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
sblock.fs_bsize, &iobuf[start]);
}
}
}
void chunk::pickblock(ubyte x, ubyte y, ubyte z){
//这个sub根本没有存在的必要，其功能等于setblock(x,y,z,0)或putblock(x,y,z,0),但是本人的完...
setblock(x, y, z, blocks::AIR);
}
void chunk::putblock(ubyte x, ubyte y, ubyte z, block iblock){
//这个sub和上面那个是一样的，只是本人的完美主义（说白了就是强迫症）驱使我再写一遍= =
setblock(x, y, z, iblock);
}
/**
* @brief connect to a host
*
* @see
* @note
* h: pointer to s_host_t
* recv_sec: receive timeout seconds, 0 for never timeout
* return the socket when succ
* return < 0 when error, specially HOST_DOWN_FAIL indicate host dead
* @author auxten <*****@*****.**> <*****@*****.**>
* @date 2011-8-1
**/
int connect_host(s_host_t * h, int recv_sec, int send_sec)
{
int sock = -1;
int ret;
int select_ret;
int res;
socklen_t res_size = sizeof res;
struct sockaddr_in channel;
in_addr_t host;
int addr_len;
struct timeval recv_timeout;
struct timeval send_timeout;
#if HAVE_POLL
#else
fd_set wset;
#endif /* HAVE_POLL */
addr_len = getaddr_my(h->addr, &host);
if (FAIL_CHECK(!addr_len))
{
gko_log(WARNING, "gethostbyname %s error", h->addr);
ret = -1;
goto CONNECT_END;
}
sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (FAIL_CHECK(sock < 0))
{
gko_log(WARNING, "get socket error");
ret = -1;
goto CONNECT_END;
}
recv_timeout.tv_usec = 0;
recv_timeout.tv_sec = recv_sec ? recv_sec : RCV_TIMEOUT;
send_timeout.tv_usec = 0;
send_timeout.tv_sec = send_sec ? send_sec : SND_TIMEOUT;
memset(&channel, 0, sizeof(channel));
channel.sin_family = AF_INET;
memcpy(&channel.sin_addr.s_addr, &host, addr_len);
channel.sin_port = htons(h->port);
/** set the connect non-blocking then blocking for add timeout on connect **/
if (FAIL_CHECK(setnonblock(sock) < 0))
{
gko_log(WARNING, "set socket non-blocking error");
ret = -1;
goto CONNECT_END;
}
/** connect and send the msg **/
if (FAIL_CHECK(connect(sock, (struct sockaddr *) &channel, sizeof(channel)) &&
errno != EINPROGRESS))
{
gko_log(WARNING, "connect error");
ret = HOST_DOWN_FAIL;
goto CONNECT_END;
}
/** Wait for write bit to be set **/
#if HAVE_POLL
{
struct pollfd pollfd;
pollfd.fd = sock;
pollfd.events = POLLOUT;
/* send_sec is in seconds, timeout in ms */
select_ret = poll(&pollfd, 1, (int)(send_sec * 1000 + 1));
}
#else
{
FD_ZERO(&wset);
FD_SET(sock, &wset);
select_ret = select(sock + 1, 0, &wset, 0, &send_timeout);
}
#endif /* HAVE_POLL */
if (select_ret < 0)
{
gko_log(WARNING, "select/poll error on connect");
ret = HOST_DOWN_FAIL;
goto CONNECT_END;
}
if (!select_ret)
{
gko_log(WARNING, "connect timeout on connect");
ret = HOST_DOWN_FAIL;
goto CONNECT_END;
}
/**
* check if connection is RESETed, maybe this is the
* best way to do that
* SEE: http://cr.yp.to/docs/connect.html
**/
(void) getsockopt(sock, SOL_SOCKET, SO_ERROR, &res, &res_size);
if (CONNECT_DEST_DOWN(res))
{
// gko_log(NOTICE, "connect dest is down errno: %d", res);
ret = HOST_DOWN_FAIL;
goto CONNECT_END;
}
///gko_log(WARNING, "selected %d ret %d, time %d", sock, select_ret, send_timeout.tv_sec);
/** set back blocking **/
if (FAIL_CHECK(setblock(sock) < 0))
{
gko_log(WARNING, "set socket non-blocking error");
ret = -1;
goto CONNECT_END;
}
/** set recv & send timeout **/
if (FAIL_CHECK(setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *) &recv_timeout,
sizeof(struct timeval))))
{
gko_log(WARNING, "setsockopt SO_RCVTIMEO error");
ret = -1;
goto CONNECT_END;
}
if (FAIL_CHECK(setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *) &send_timeout,
sizeof(struct timeval))))
{
gko_log(WARNING, "setsockopt SO_SNDTIMEO error");
ret = -1;
goto CONNECT_END;
}
ret = sock;
CONNECT_END:
///
if (ret < 0 && sock >= 0)
{
close_socket(sock);
}
return ret;
}
