�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FGIX_FTP%2F'>GIX_FTP</a>/<a href='?path=%2Fbig%2FGIX_FTP%2Fsrc%2F'>src</a>/</p><hr><h3>✏️ Editing: tget.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;sys/poll.h&gt;
#include &lt;sys/wait.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;sys/file.h&gt;
#include &lt;stdio.h&gt;
#include &lt;fnmatch.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;dirent.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;time.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;strings.h&gt;
#include &lt;unistd.h&gt;
#include &lt;signal.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;errno.h&gt;
#ifdef HAVE_MODE_Z
#include &lt;zlib.h&gt;
#endif
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;netdb.h&gt;
#include &lt;libpq-fe.h&gt;
#include &lt;openssl/ssl.h&gt;
#include &lt;openssl/bio.h&gt;
#include &lt;openssl/x509.h&gt;
#include &lt;openssl/err.h&gt;
#include &lt;utime.h&gt;
#ifndef NOZIP
#include &lt;zip.h&gt;
#endif
#include &quot;tools.h&quot;
#include &quot;jftpd.h&quot;

#define USERNAME    argv[1]
#define PASSWORD    argv[2]
#define SERVER      argv[3]
#define REMOTE_FILE argv[4]
#define LOCAL_FILE  argv[5]

#define BFSIZE 4096


int mode_put;
char print_ip[128];

int check_logout(struct conn *co, char reason){ // Dummy
	return(0);
}
#define now (&amp;_now)

#define FACTOR1000 ((double)1024)
char *getthroughput(u_int64_t wire_data,u_int64_t file_data,struct timeval *start){
	static char info[1024];
	struct timeval _now;
	double delta;
	double throughput;
	if ( wire_data == (u_int64_t)0 ) return(&quot;&quot;);
	if ( file_data == (u_int64_t)0 ) return(&quot;&quot;);
	gettimeofday(now,NULL);
	delta = (((double) now-&gt;tv_sec) + (((double)now-&gt;tv_usec)/((double)1000000))) - 
		(((double) start-&gt;tv_sec) + (((double)start-&gt;tv_usec)/((double)1000000)));
	throughput = ((double)file_data)/delta;

	if ( throughput &gt; (FACTOR1000 * FACTOR1000 * FACTOR1000 * FACTOR1000) ){
		sprintf(info,&quot;%.02f TB/s&quot;, throughput / (FACTOR1000 * FACTOR1000 * FACTOR1000 * FACTOR1000));
	} else if ( throughput &gt; (FACTOR1000 * FACTOR1000 * FACTOR1000) ){
		sprintf(info,&quot;%.02f GB/s&quot;, throughput / (FACTOR1000 * FACTOR1000 * FACTOR1000));
	} else if ( throughput &gt; (FACTOR1000 * FACTOR1000) ){
		sprintf(info,&quot;%.02f MB/s&quot;, throughput / (FACTOR1000 * FACTOR1000));
	} else if ( throughput &gt; (FACTOR1000) ){
		sprintf(info,&quot;%.02f KB/s&quot;, throughput / (FACTOR1000));
	} else {
		sprintf(info,&quot;%.02f Bytes/s&quot;, throughput );
	}

	if ( wire_data != file_data ){
		sprintf(&amp;info[strlen(info)],&quot; Compression: %.02f%%&quot;,(1.0 - ((double)wire_data) / ((double)file_data)) * 100.0 );

	}


	return(info);
}
#undef now

char *display_percent(u_int64_t total, u_int64_t done){
	static char info[1024];
	sprintf(info,&quot;%.02f%%&quot;, (((double)done)/((double)total)) * 100.0);
	return(info);
}

char *displaytime(struct timeval *start, struct timeval *now){
	static char info[1024];
	double delta2;
	double delta;
	int hours;
	int mins;
	double secs;
	double _start;
	double _now;





	_now   = (((double) now-&gt;tv_sec) +   (((double)now-&gt;tv_usec)/((double)1000000)));
	_start = (((double) start-&gt;tv_sec) + (((double)start-&gt;tv_usec)/((double)1000000)));

	delta = _now - _start;




	printf(&quot;&quot;,delta);


	hours = (int)(delta / ((double) 3600));
	delta -= ((double)hours) * ((double)3600);
	mins = (int)(delta / ((double) 60));
	delta -= ((double)mins) * ((double)3600);
	secs = delta / ((double) 60);


	sprintf(info,&quot;&quot;);

	if ( hours ) sprintf(&amp;info[strlen(info)],&quot;%d hours, &quot;,hours);


	if ( mins ) sprintf(&amp;info[strlen(info)],&quot;%d minutes, &quot;,hours);

	sprintf(&amp;info[strlen(info)],&quot;%.04f seconds. &quot;,hours);

	return(info);

}

char *displaysize(u_int64_t sizer){
	static char info[1024];
	double throughput;

	throughput = (double) sizer;
	if ( throughput &gt; (FACTOR1000 * FACTOR1000 * FACTOR1000 * FACTOR1000) ){
		sprintf(info,&quot;%.02f TB&quot;, throughput / (FACTOR1000 * FACTOR1000 * FACTOR1000 * FACTOR1000));
	} else if ( throughput &gt; (FACTOR1000 * FACTOR1000 * FACTOR1000) ){
		sprintf(info,&quot;%.02f GB&quot;, throughput / (FACTOR1000 * FACTOR1000 * FACTOR1000));
	} else if ( throughput &gt; (FACTOR1000 * FACTOR1000) ){
		sprintf(info,&quot;%.02f MB&quot;, throughput / (FACTOR1000 * FACTOR1000));
	} else if ( throughput &gt; (FACTOR1000) ){
		sprintf(info,&quot;%.02f KB&quot;, throughput / (FACTOR1000));
	} else {
		sprintf(info,&quot;%.02f Bytes&quot;, throughput );
	}
	return(info);
}

int getsockline(int sock, unsigned char *buf){
	int received;
	unsigned char c;
	received = 0;
	buf[received] = 0x00;
	while ( recv(sock,&amp;c,1,0) == 1 ){
		if ( c == &#039;\n&#039; ) break;
		if ( c == &#039;\r&#039; ) continue;
		buf[received++] = c;
		buf[received] = 0x00;
	}
	return(received);
}


int main(int argc, char **argv){
	char the_throughput[256];
	char buf[1024];
	int sock;
	int dsock;
	struct timeval start;
	struct timeval end;
	u_int64_t transfer_size;
	struct addrinfo *res, *rp;
	struct addrinfo hints;
	int result;
	int has_mode_z;
	u_int64_t size;
	u_int64_t filesize;
	unsigned short port;
	struct sockaddr *remote;
	int remote_len;
	int local;
	u_int64_t file_data;
	u_int64_t wire_data;
	u_int64_t file_offset;

	if ( argc &lt; 6 ){
		printf(&quot;Usage: %s &lt;username&gt; &lt;password&gt; &lt;server&gt; &lt;remote-file&gt; &lt;local-file&gt; [nocompress]\n&quot;,argv[0]);
		exit(2);
	}

	has_mode_z = 0;

	the_throughput[0] = 0x00;

	if ( strstr(argv[0],&quot;put&quot;) )
		mode_put = 1;
	else
		mode_put = 0;

	if ( mode_put ){
		struct stat st;
		if ( stat(LOCAL_FILE,&amp;st) == 0 &amp;&amp; st.st_size ){
			printf(&quot;File [%s] has %ju Bytes\n&quot;,LOCAL_FILE,(u_int64_t)st.st_size);
			filesize = (u_int64_t)st.st_size;
		} else {
			printf(&quot;%s does not exist or has 0 size!\n&quot;,LOCAL_FILE);
			exit(2);
		}

	} else {
		struct stat st;
		if ( stat(LOCAL_FILE,&amp;st) == 0 ){
			file_offset = (u_int64_t)st.st_size;
			printf(&quot;File [%s] has %ju Bytes, transfer will append from offset\n&quot;,LOCAL_FILE,file_offset);
		} else {
			file_offset = (u_int64_t)0;
		}
	}

	bzero(&amp;hints,sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	result = getaddrinfo(SERVER,&quot;21&quot;,&amp;hints,&amp;res);
	if ( result != 0 ){
		printf(&quot;Cannot resolve hostname &#039;%s&#039; (%s)\n&quot;,SERVER,gai_strerror(result));
		exit(2);
	}
	for ( rp = res; rp != NULL; rp = rp-&gt;ai_next ){
		int oldflags;
		int newflags;
		struct pollfd polly;
		if ( rp-&gt;ai_family != AF_INET &amp;&amp; rp-&gt;ai_family != AF_INET6 ) continue;

		if ( rp-&gt;ai_family == AF_INET ){
			struct sockaddr_in *me;
			me = (struct sockaddr_in *)rp-&gt;ai_addr;
			inet_ntop(AF_INET,&amp;me-&gt;sin_addr.s_addr,print_ip,128);
		} else if ( rp-&gt;ai_family == AF_INET6 ){
			struct sockaddr_in6 *me;
			me = (struct sockaddr_in6 *)rp-&gt;ai_addr;
			inet_ntop(AF_INET6,&amp;me-&gt;sin6_addr,print_ip,128);
		}
		printf(&quot;Trying %s...&quot;,print_ip);
		sock = socket(rp-&gt;ai_family,rp-&gt;ai_socktype,rp-&gt;ai_protocol); 
		if ( sock &lt; 0 ){
			printf(&quot;FAIL!\nCannot create socket! (%s)\n&quot;,strerror(errno));
			continue;
		}	
		if ( ( oldflags = fcntl(sock,F_GETFL)) == -1 ){
			close(sock);
			printf(&quot;FAIL!\nCannot fcntl-get (NON-BLOCKING) socket! (%s)\n&quot;,strerror(errno));
			continue;
		}
		newflags = oldflags | O_NONBLOCK;

		if ( fcntl(sock,F_SETFL,newflags) == -1 ){
			close(sock);
			printf(&quot;FAIL!\nCannot fcntl-set (NON-BLOCKING) socket! (%s)\n&quot;,strerror(errno));
			continue;
		}
		
		if ( connect(sock,rp-&gt;ai_addr,rp-&gt;ai_addrlen) &lt; 0 &amp;&amp; errno != EINPROGRESS ){
			close(sock);
			printf(&quot;FAIL!\nCannot connect socket! (%s)\n&quot;,strerror(errno));
			continue;
		}
		fflush(stdout);

		polly.fd = sock;
		polly.events = POLLIN | POLLOUT | POLLHUP | POLLERR;
		polly.revents = 0;

		if ( (result =  poll(&amp;polly,1,10000)) &lt; 0 ){
			close(sock);
			printf(&quot;FAIL!\nCannot poll socket! (%s)\n&quot;,strerror(errno));
			continue;
		}
		if ( result == 0 ){
			printf(&quot;TIMEOUT!\n&quot;);
			close(sock);
			continue;
		}
		if ( result == 1 ){
			if ( (polly.revents &amp; POLLIN) || (polly.revents &amp; POLLOUT) ){
				if ( fcntl(sock,F_SETFL,oldflags) == -1 ){
					close(sock);
					printf(&quot;FAIL!\nCannot fcntl-set (BLOCKING) socket! (%s)\n&quot;,strerror(errno));
					continue;
				}
				printf(&quot;OK!\n&quot;);
				break;
			} else {
				close(sock);
				printf(&quot;FAILED!\n&quot;);
				continue;
			}
		} 
		close(sock);
	}
	if ( rp == NULL ){
		printf(&quot;\nFATAL!!!\nCould not connect!\n&quot;);
		exit(0);
	}
	while ( getsockline(sock,buf) &gt; 0 ){
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
		result = atoi(buf);
		if ( buf[3] != &#039;-&#039; ) break;
	}
	if ( result &lt; 200 || result &gt; 299 ){
		close(sock);
		printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	sprintf(buf,&quot;USER %s&quot;,USERNAME);
	printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
	send(sock,buf,strlen(buf),0);
	while ( getsockline(sock,buf) &gt; 0 ){
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
		result = atoi(buf);
		if ( buf[3] != &#039;-&#039; ) break;
	}
	if ( result &gt;= 300 &amp;&amp; result &lt; 400 ){
		sprintf(buf,&quot;PASS %s&quot;,PASSWORD);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
	}
	if ( result &lt; 200 || result &gt; 299 ){
		close(sock);
		printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	if ( argc &lt; 7 ){
		sprintf(buf,&quot;MODE Z&quot;);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
		if ( result &gt;= 200 &amp;&amp; result &lt; 300 ) 
			has_mode_z = 1;
		else
			has_mode_z = 0;
	}

	printf(&quot;** Use Compression: [%s]\n&quot;,has_mode_z ? &quot;YES&quot; : &quot;NO&quot;);
	sprintf(buf,&quot;TYPE I&quot;);
	printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
	send(sock,buf,strlen(buf),0);
	while ( getsockline(sock,buf) &gt; 0 ){
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
		result = atoi(buf);
		if ( buf[3] != &#039;-&#039; ) break;
	}
	if ( result &lt; 200 || result &gt; 299 ){
		close(sock);
		printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	if ( mode_put == 0 ){
		sprintf(buf,&quot;SIZE %s&quot;,REMOTE_FILE);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
		if ( result &lt; 200 || result &gt; 299 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		if ( sscanf(buf,&quot;%d %ju&quot;,&amp;result,&amp;filesize) != 2 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		printf(&quot;** Will receive %ju Bytes\n&quot;,filesize);
	}
	if ( rp-&gt;ai_family == AF_INET6 ){
		static struct sockaddr_in6 remoty;
		char *ptr;
		int lines;
		sprintf(buf,&quot;EPSV&quot;);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
		if ( result &lt; 200 || result &gt; 299 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		lines = 0;
		ptr = buf;
		while ( *ptr ){
			if ( *ptr == &#039;|&#039; ) lines++;
			ptr++;
			if ( lines == 3 ) break;
		}
		if ( lines != 3 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		port = (unsigned short)atoi(ptr);
		printf(&quot;** IPv6: Using Port: %d\n&quot;,port);
		bzero(&amp;remoty,sizeof(struct sockaddr_in6));
		remoty.sin6_family = AF_INET6;
		remoty.sin6_port   = htons(port);
		inet_pton(AF_INET6,print_ip,&amp;remoty.sin6_addr);
		remote = (struct sockaddr *)&amp;remoty;
		remote_len = sizeof(struct sockaddr_in6);
		if ( (dsock = socket(AF_INET6,SOCK_STREAM,0)) &lt; 0 ){
			close(sock);
			printf(&quot;[%s:%d] Cannot create data-socket (%s)\n&quot;,__FILE__,__LINE__,strerror(errno));
			exit(3);
		}
	} else {
		static struct sockaddr_in remoty;
		unsigned short low;
		unsigned short high;
		char *ptr;
		int lines;
		sprintf(buf,&quot;PASV&quot;);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
		if ( result &lt; 200 || result &gt; 299 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		lines = 0;
		ptr = buf;
		while ( *ptr ){
			if ( *ptr == &#039;,&#039; ) lines++;
			ptr++;
			if ( lines == 4 ) break;
		}
		if ( lines != 4 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		high = (unsigned short)atoi(ptr);
		ptr = strstr(ptr,&quot;,&quot;);
		if ( ptr == NULL ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		ptr++;
		low = (unsigned short)atoi(ptr);
		port = high * 256 + low;
		printf(&quot;** IPv4: Using Port: %d\n&quot;,port);
		bzero(&amp;remoty,sizeof(struct sockaddr_in));
		remoty.sin_family = AF_INET;
		remoty.sin_port   = htons(port);
		remoty.sin_addr.s_addr = inet_addr(print_ip);
		remote = (struct sockaddr *)&amp;remoty;
		remote_len = sizeof(struct sockaddr_in);
		if ( (dsock = socket(AF_INET,SOCK_STREAM,0)) &lt; 0 ){
			close(sock);
			printf(&quot;[%s:%d] Cannot create data-socket (%s)\n&quot;,__FILE__,__LINE__,strerror(errno));
			exit(3);
		}
	}
	if ( connect(dsock,remote,remote_len) &lt; 0 ){
			close(sock);
			printf(&quot;[%s:%d] Cannot connect data-socket (%s)\n&quot;,__FILE__,__LINE__,strerror(errno));
			exit(3);
	}
	printf(&quot;*** Data socket connected\n&quot;);
	if ( mode_put ){
		local = open(LOCAL_FILE,O_RDONLY);
		if ( local &lt; 0 ){
			printf(&quot;FATAL!!! Cannot open &#039;%s&#039; for reading (%s)\n&quot;,LOCAL_FILE,strerror(errno));
			exit(3);
		}
		sprintf(buf,&quot;STOR %s&quot;,REMOTE_FILE);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
		if ( result &lt; 100 || result &gt; 199 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		wire_data = (u_int64_t)0;
		file_data = (u_int64_t)0;
#define ZLIB_CHUNK2 128000
#define ZLIB_CHUNKSIZE 256000
		gettimeofday(&amp;start,NULL);
		if ( has_mode_z ){
			char oldusage[128];
			char newusage[128];
			int buf_read;
			int real_sent;
			int nsent;
			int cnt;
			int have;
			int flush;
			char buf_in[ZLIB_CHUNK2];
			char buf_out[ZLIB_CHUNK2];
			off_t lseeker;
			z_stream strm;

			strm.zalloc = Z_NULL;
			strm.zfree  = Z_NULL;
			strm.opaque = Z_NULL;
			result = deflateInit(&amp;strm,9);
			if ( result != Z_OK ){
				close(sock);
				printf(&quot;[%s:%d] FATAL ZLIB init failed!\n&quot;,__FILE__,__LINE__);
				exit(3);
			}
			while ( (cnt = read(local,buf_in,ZLIB_CHUNK2)) &gt; 0 ){
				strm.next_in = buf_in;
				strm.avail_in = cnt;
				file_data += cnt;
				if ( (u_int64_t)(lseeker = lseek(local,0,SEEK_CUR)) == filesize ){
					flush = Z_FINISH;
				} else {
					flush = Z_NO_FLUSH;
				}
				do {
					strm.avail_out = ZLIB_CHUNK2;
					strm.next_out  = buf_out;
					result = deflate(&amp;strm,flush);
					have = ZLIB_CHUNK2 - strm.avail_out;
					if ( result != Z_OK &amp;&amp; result != Z_STREAM_END ){
						close(sock);
						printf(&quot;[%s:%d] FATAL ZLIB inflate failed!\n&quot;,__FILE__,__LINE__);
						exit(3);
					}
					wire_data += have;
					real_sent = 0;
					while ( real_sent != have ){
						nsent = send(dsock,&amp;buf_out[real_sent],have - real_sent,0);
						if ( nsent &lt;= 0 ){
							close(sock);
							printf(&quot;[%s:%d] Local write error (%s)!\n&quot;,__FILE__,__LINE__,strerror(errno));
							exit(3);
						}
						real_sent += nsent;
					}
					strcpy(newusage,display_percent(filesize,file_data));
					if ( strcmp(oldusage,newusage) != 0 ){
						strcpy(oldusage,newusage);
						printf(&quot;Data sent: %s (%s)\r&quot;,oldusage ,getthroughput(wire_data,file_data,&amp;start));
						fflush(stdout);
					}
				} while(strm.avail_out == 0 );
				if ( result == Z_STREAM_END )  break;
			}
			deflateEnd(&amp;strm);
			strcpy(the_throughput,getthroughput(wire_data,file_data,&amp;start));
			close(local);
			close(dsock);
		} else {
			char oldusage[128];
			char newusage[128];
			int buf_read;
			int real_sent;
			int nsent;
			char buf[BFSIZE];
			strcpy(oldusage,&quot;&quot;);
			while ( (buf_read = read(local,buf,BFSIZE)) &gt; 0 ){
				wire_data += (u_int64_t) buf_read;
				file_data += (u_int64_t) buf_read;
				real_sent = 0;
				while ( real_sent != buf_read ){
					nsent = send(dsock,&amp;buf[real_sent],buf_read - real_sent,0);
					if ( nsent &lt;= 0 ){
						close(sock);
						printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
						exit(3);
					}
					real_sent += nsent;
				}
				strcpy(newusage,display_percent(filesize,file_data));
				if ( strcmp(oldusage,newusage) != 0 ){
					strcpy(oldusage,newusage);
					printf(&quot;Data sent: %s (%s)\r&quot;,oldusage ,getthroughput(wire_data,file_data,&amp;start));
					fflush(stdout);
				}
					
			}
			strcpy(the_throughput,getthroughput(wire_data,file_data,&amp;start));
			close(local);
			close(dsock);

		}
	} else {
		if ( file_offset ){
			local = open(LOCAL_FILE,O_APPEND | O_WRONLY);
			if ( local &lt; 0 ){
				printf(&quot;FATAL!!! Cannot open &#039;%s&#039; for appending (%s)\n&quot;,LOCAL_FILE,strerror(errno));
				exit(3);
			}
			sprintf(buf,&quot;REST %ju&quot;,file_offset);
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
			send(sock,buf,strlen(buf),0);
			while ( getsockline(sock,buf) &gt; 0 ){
				printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
				result = atoi(buf);
				if ( buf[3] != &#039;-&#039; ) break;
			}
			if ( result &lt; 300 || result &gt; 399 ){
				close(sock);
				printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
				exit(3);
			}
		} else {
			unlink(LOCAL_FILE);
			local = open(LOCAL_FILE,O_WRONLY | O_CREAT,0644);
			if ( local &lt; 0 ){
				printf(&quot;FATAL!!! Cannot open &#039;%s&#039; for writing (%s)\n&quot;,LOCAL_FILE,strerror(errno));
				exit(3);
			}
		}
		sprintf(buf,&quot;RETR %s&quot;,REMOTE_FILE);
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf); strcat(buf,&quot;\r\n&quot;);
		send(sock,buf,strlen(buf),0);
		while ( getsockline(sock,buf) &gt; 0 ){
			printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
			result = atoi(buf);
			if ( buf[3] != &#039;-&#039; ) break;
		}
		if ( result &lt; 100 || result &gt; 199 ){
			close(sock);
			printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
			exit(3);
		}
		gettimeofday(&amp;start,NULL);
		if ( has_mode_z ){
			char oldusage[128];
			char newusage[128];
			int buf_read;
			int real_sent;
			int nsent;
			int cnt;
			int have;
			char buf_in[ZLIB_CHUNK2];
			char buf_out[ZLIB_CHUNKSIZE];
			z_stream strm;

			strm.zalloc = Z_NULL;
			strm.zfree  = Z_NULL;
			strm.opaque = Z_NULL;
			result = inflateInit(&amp;strm);
			if ( result != Z_OK ){
				close(sock);
				printf(&quot;[%s:%d] FATAL ZLIB init failed!\n&quot;,__FILE__,__LINE__);
				exit(3);
			}
			while ( 1 ){
				int sock_received;
				sock_received = 0;
				while ( sock_received &lt; ZLIB_CHUNK2 &amp;&amp; (cnt = recv(dsock,&amp;buf_in[sock_received],ZLIB_CHUNK2 - sock_received,0)) &gt; 0 ){
					sock_received += cnt;
				}
				if ( sock_received == 0 ) break;
				if ( sock_received != ZLIB_CHUNK2 ){
					fprintf(stderr,&quot;\nSOCK_RECEIVED: %d\n&quot;,sock_received);
				}
				cnt = sock_received;
				strm.next_in = buf_in;
				strm.avail_in = cnt;
				wire_data += cnt;
				do {
					strm.avail_out = ZLIB_CHUNKSIZE;
					strm.next_out  = buf_out;
					result = inflate(&amp;strm,Z_SYNC_FLUSH);
					have = ZLIB_CHUNKSIZE - strm.avail_out;
					if ( result != Z_OK &amp;&amp; result != Z_STREAM_END &amp;&amp; result != Z_BUF_ERROR){
						close(sock);
						printf(&quot;[%s:%d] FATAL ZLIB inflate failed! (CNT: %d), RESULT: %d\n&quot;,__FILE__,__LINE__,cnt,result);
						exit(3);
					}
					file_data += have;
					real_sent = 0;
					while ( real_sent != have ){
						nsent = write(local,&amp;buf_out[real_sent],have - real_sent);
						if ( nsent &lt;= 0 ){
							close(sock);
							printf(&quot;[%s:%d] Local write error (%s)!\n&quot;,__FILE__,__LINE__,strerror(errno));
							exit(3);
						}
						real_sent += nsent;
					}
					strcpy(newusage,display_percent(filesize,file_data));
					if ( strcmp(oldusage,newusage) != 0 ){
						strcpy(oldusage,newusage);
						printf(&quot;Data recvd: %s (%s)\r&quot;,oldusage ,getthroughput(wire_data,file_data,&amp;start));
						fflush(stdout);
					}
				} while(strm.avail_out == 0 );
				if ( result == Z_STREAM_END )  break;
			}
			inflateEnd(&amp;strm);
			strcpy(the_throughput,getthroughput(wire_data,file_data,&amp;start));
			close(local);
			close(dsock);
		} else {
			char oldusage[128];
			char newusage[128];
			int buf_read;
			int real_sent;
			int nsent;
			char buf[BFSIZE];
			strcpy(oldusage,&quot;&quot;);
			while ( (buf_read = recv(dsock,buf,BFSIZE,0)) &gt; 0 ){
				wire_data += (u_int64_t) buf_read;
				file_data += (u_int64_t) buf_read;
				real_sent = 0;
				while ( real_sent != buf_read ){
					nsent = write(local,&amp;buf[real_sent],buf_read - real_sent);
					if ( nsent &lt;= 0 ){
						close(sock);
						printf(&quot;[%s:%d] Local write error (%s)!\n&quot;,__FILE__,__LINE__,strerror(errno));
						exit(3);
					}
					real_sent += nsent;
				}
				strcpy(newusage,display_percent(filesize,file_data));
				if ( strcmp(oldusage,newusage) != 0 ){
					strcpy(oldusage,newusage);
					printf(&quot;Data recvd: %s (%s)\r&quot;,oldusage ,getthroughput(wire_data,file_data,&amp;start));
					fflush(stdout);
				}
			}
			strcpy(the_throughput,getthroughput(wire_data,file_data,&amp;start));
			close(local);
			close(dsock);
		}
	}	
	gettimeofday(&amp;end,NULL);
	printf(&quot;\n&quot;);
	while ( getsockline(sock,buf) &gt; 0 ){
		printf(&quot;&gt;&gt; [%s]\n&quot;,buf);
		result = atoi(buf);
		if ( buf[3] != &#039;-&#039; ) break;
	}
	if ( result &lt; 200 || result &gt; 299 ){
		close(sock);
		printf(&quot;[%s:%d] Protocol error!\n&quot;,__FILE__,__LINE__);
		exit(3);
	}
	printf(&quot;----------------------------------------------------------------------\n&quot;);
	printf(&quot;Mode:          %s\n&quot;,mode_put ? &quot;PUT&quot; : &quot;GET&quot;);
	printf(&quot;Compression:   %s\n&quot;,has_mode_z ? &quot;YES&quot; : &quot;NO&quot;);
	printf(&quot;Local-File:    %s\n&quot;,LOCAL_FILE);
	printf(&quot;Remte-File:    %s\n&quot;,REMOTE_FILE);
	printf(&quot;Total time:    %s\n&quot;,displaytime(&amp;start,&amp;end));
	printf(&quot;Wire-Transfer: %s\n&quot;,displaysize(wire_data));
	printf(&quot;File-Transfer: %s\n&quot;,displaysize(file_data));
	printf(&quot;Throughput:    %s\n&quot;,the_throughput);
	printf(&quot;----------------------------------------------------------------------\n&quot;);

	exit(0);
}


</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FGIX_FTP%2Fsrc'>🔙 Back</a></p>