void send_to_logger( int send_to_status_fd, int send_to_mail_fd,
struct job *job, const char *header, char *msg_b )
{
char *s, *t;
char *id, *tstr;
int num,pid;
char out_b[4*SMALLBUFFER];
struct line_list l;
if( !Is_server || Doing_cleanup ) return;
Init_line_list(&l);
if(DEBUGL4){
char buffer[32];
plp_snprintf(buffer,sizeof(buffer)-5, "%s", msg_b );
if( msg_b ) safestrncat( buffer,"...");
LOGDEBUG("send_to_logger: Logger_fd fd %d, send_to_status_fd %d, send_to_mail fd %d, header '%s', body '%s'",
Logger_fd, send_to_status_fd, send_to_mail_fd, header, buffer );
}
if( send_to_status_fd <= 0 && send_to_mail_fd <= 0 && Logger_fd <= 0 ) return;
s = t = id = tstr = 0;
num = 0;
if( job ){
Set_str_value(&l,IDENTIFIER,
(id = Find_str_value(&job->info,IDENTIFIER)) );
Set_decimal_value(&l,NUMBER,
(num = Find_decimal_value(&job->info,NUMBER)) );
}
Set_str_value(&l,UPDATE_TIME,(tstr=Time_str(0,0)));
Set_decimal_value(&l,PROCESS,(pid=getpid()));
plp_snprintf( out_b, sizeof(out_b), "%s at %s ## %s=%s %s=%d %s=%d\n",
msg_b, tstr, IDENTIFIER, id, NUMBER, num, PROCESS, pid );
if( send_to_status_fd > 0 && Write_fd_str( send_to_status_fd, out_b ) < 0 ){
DEBUG4("send_to_logger: write to send_to_status_fd %d failed - %s",
send_to_status_fd, Errormsg(errno) );
}
if( send_to_mail_fd > 0 && Write_fd_str( send_to_mail_fd, out_b ) < 0 ){
DEBUG4("send_to_logger: write to send_to_mail_fd %d failed - %s",
send_to_mail_fd, Errormsg(errno) );
}
if( Logger_fd > 0 ){
Set_str_value(&l,PRINTER,Printer_DYN);
Set_str_value(&l,HOST,FQDNHost_FQDN);
s = Escape(msg_b,1);
Set_str_value(&l,VALUE,s);
if(s) free(s); s = 0;
t = Join_line_list(&l,"\n");
s = Escape(t,1);
if(t) free(t); t = 0;
t = safestrdup4(header,"=",s,"\n",__FILE__,__LINE__);
Write_fd_str( Logger_fd, t );
if( s ) free(s); s = 0;
if( t ) free(t); t = 0;
}
Free_line_list(&l);
}
BOOL
Mych(
DWORD ctrlT
)
{
char c[2];
DWORD tmp;
DWORD send=1;
c[0]=CTRLC;
if (ctrlT==CTRL_C_EVENT)
{
if (!WriteFile(WritePipe,c,send,&tmp,NULL))
{
Errormsg("Error Sending ^c\n");
return(FALSE);
}
return(TRUE);
}
if ((ctrlT==CTRL_BREAK_EVENT)||
(ctrlT==CTRL_CLOSE_EVENT)||
(ctrlT==CTRL_LOGOFF_EVENT)||
(ctrlT==CTRL_SHUTDOWN_EVENT)
)
{
CloseHandle(WritePipe); //Will Shutdown naturally
}
return(FALSE);
}
int tcp_open( int port )
{
int i, fd, err;
struct sockaddr_in sinaddr;
sinaddr.sin_family = AF_INET;
sinaddr.sin_addr.s_addr = INADDR_ANY;
sinaddr.sin_port = htons( port );
fd = socket( AF_INET, SOCK_STREAM, 0 );
#ifdef WINDOW_1
int windowsize=1024;
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&windowsize, sizeof(windowsize));
//aaaaaa=fopen("/tmp/qqqqq", "a");
//fprintf(aaaaaa, " monitor: tcp_send\n");
//fclose(aaaaaa);
#endif
Max_open(fd);
err = errno;
if( fd < 0 ){
FPRINTF(STDERR,"tcp_open: socket call failed - %s\n", Errormsg(err) );
return( -1 );
}
i = Link_setreuse( fd );
if( i >= 0 ) i = bind( fd, (struct sockaddr *) & sinaddr, sizeof (sinaddr) );
if( i >= 0 ) i = listen( fd, 10 );
err = errno;
if( i < 0 ){
FPRINTF(STDERR,"tcp_open: connect to '%s port %d' failed - %s\n",
inet_ntoa( sinaddr.sin_addr ), ntohs( sinaddr.sin_port ),
Errormsg(errno) );
close(fd);
fd = -1;
}
if( fd == 0 ){
fd = dup(fd);
if( fd < 0 ){
FPRINTF(STDERR,"tcp_open: dup failed - %s\n",
Errormsg(errno) );
close(fd);
fd = -1;
}
}
return( fd );
}
int udp_open( int port )
{
int i, fd, err;
struct sockaddr_in sinaddr;
sinaddr.sin_family = AF_INET;
sinaddr.sin_addr.s_addr = INADDR_ANY;
sinaddr.sin_port = htons( port );
fd = socket( AF_INET, SOCK_DGRAM, 0 );
Max_open(fd);
err = errno;
if( fd < 0 ){
FPRINTF(STDERR,"udp_open: socket call failed - %s\n", Errormsg(err) );
return( -1 );
}
i = -1;
i = bind( fd, (struct sockaddr *) & sinaddr, sizeof (sinaddr) );
err = errno;
if( i < 0 ){
FPRINTF(STDERR,"udp_open: bind to '%s port %d' failed - %s\n",
inet_ntoa( sinaddr.sin_addr ), ntohs( sinaddr.sin_port ),
Errormsg(errno) );
close(fd);
fd = -1;
}
if( fd == 0 ){
fd = dup(fd);
if( fd < 0 ){
FPRINTF(STDERR,"udp_open: dup failed - %s\n",
Errormsg(errno) );
close(fd);
fd = -1;
}
}
return( fd );
}
HANDLE*
EstablishSession(
char *server,
char *srvpipename
)
{
static HANDLE PipeH[2];
char pipenameSrvIn[200];
char pipenameSrvOut[200];
sprintf(pipenameSrvIn ,SERVER_READ_PIPE ,server,srvpipename);
sprintf(pipenameSrvOut,SERVER_WRITE_PIPE,server,srvpipename);
if ((INVALID_HANDLE_VALUE==(PipeH[0]=CreateFile(pipenameSrvOut,
GENERIC_READ ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL))) ||
(INVALID_HANDLE_VALUE==(PipeH[1]=CreateFile(pipenameSrvIn ,
GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL)))) {
DWORD Err=GetLastError();
char msg[128];
Errormsg("*** Unable to Connect ***");
//
// Print a helpful message
//
switch(Err)
{
case 2: sprintf(msg,"Invalid PipeName %s",srvpipename);break;
case 53:sprintf(msg,"Server %s not found",server);break;
default:
FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, Err, 0, msg, 128, NULL);
break;
}
WRITEF((VBuff,"Diagnosis:%s\n",msg));
return(NULL);
}
WRITEF((VBuff,"Connected..\n\n"));
SendMyInfo(PipeH);
return(PipeH);
}
static int Do_secure_work( char *jobsize, int from_server,
char *tempfile, struct line_list *header_info )
{
int n, len, linecount = 0, done = 0, fd, status = 0;
char *s, *t;
char buffer[SMALLBUFFER];
char error[SMALLBUFFER];
struct stat statb;
error[0] = 0;
if( (fd = Checkread(tempfile,&statb)) < 0 ){
status = JFAIL;
plp_snprintf( error, sizeof(error),
"Do_secure_work: reopen of '%s' failed - %s",
tempfile, Errormsg(errno));
goto error;
}
buffer[0] = 0;
n = 0;
done = 0;
linecount = 0;
while( !done && n < (int)sizeof(buffer)-1
&& (len = Read_fd_len_timeout( Send_query_rw_timeout_DYN, fd, buffer+n, sizeof(buffer)-1-n )) > 0 ){
buffer[n+len] = 0;
DEBUGF(DRECV1)("Do_secure_work: read %d - '%s'", len, buffer );
while( !done && (s = safestrchr(buffer,'\n')) ){
*s++ = 0;
if( safestrlen(buffer) == 0 ){
done = 1;
break;
}
DEBUGF(DRECV1)("Do_secure_work: line [%d] '%s'", linecount, buffer );
if( (t = strchr(buffer,'=')) ){
*t++ = 0;
Unescape(t);
Set_str_value(header_info, buffer, t );
} else {
switch( linecount ){
case 0:
if( jobsize ){
if( from_server ){
Set_str_value(header_info,CLIENT,buffer);
}
done = 1;
} else {
Set_str_value(header_info,INPUT,buffer); break;
}
break;
case 1:
Set_str_value(header_info,CLIENT,buffer);
done = 1;
break;
}
}
++linecount;
memmove(buffer,s,safestrlen(s)+1);
n = safestrlen(buffer);
}
}
if( fd >= 0 ) close(fd); fd = -1;
DEBUGFC(DRECV1)Dump_line_list("Do_secure_work - header", header_info );
if( (status = Check_secure_perms( header_info, from_server, error, sizeof(error))) ){
goto error;
}
DEBUGFC(DRECV1)Dump_line_list("Do_secure_work - header after check", header_info );
buffer[0] = 0;
if( jobsize ){
if( (fd = Checkread(tempfile, &statb) ) < 0 ){
status = JFAIL;
plp_snprintf( error, sizeof(error),
"Do_secure_work: reopen of '%s' for read failed - %s",
tempfile, Errormsg(errno));
goto error;
}
status = Scan_block_file( fd, error, sizeof(error), header_info );
if( (fd = Checkwrite(tempfile,&statb,O_WRONLY|O_TRUNC,1,0)) < 0 ){
status = JFAIL;
plp_snprintf( error, sizeof(error),
"Do_secure_work: reopen of '%s' for write failed - %s",
tempfile, Errormsg(errno));
goto error;
}
} else {
if( (fd = Checkwrite(tempfile,&statb,O_WRONLY|O_TRUNC,1,0)) < 0 ){
status = JFAIL;
plp_snprintf( error, sizeof(error),
"Do_secure_work: reopen of '%s' for write failed - %s",
tempfile, Errormsg(errno));
goto error;
}
if( (s = Find_str_value(header_info,INPUT)) ){
Dispatch_input( &fd, s, "from secure link" );
}
}
error:
if( fd >= 0 ) close(fd); fd = -1;
DEBUGF(DRECV1)("Do_secure_work: status %d, tempfile '%s', error '%s'",
status, tempfile, error );
if( error[0] ){
DEBUGF(DRECV1)("Do_secure_work: updating tempfile '%s', error '%s'",
tempfile, error );
if( (fd = Checkwrite(tempfile,&statb,O_WRONLY|O_TRUNC,1,0)) < 0 ){
Errorcode = JFAIL;
logerr_die(LOG_INFO, "Do_secure_work: reopen of '%s' for write failed",
tempfile );
}
Write_fd_str(fd,error);
close(fd);
}
DEBUGF(DRECV1)("Do_secure_work: returning %d", status );
return( status );
}
int main(int argc, char *argv[] )
{
int n, i, c, err, max_port = 0;
char *portname, *s;
struct servent *servent;
struct info *in;
prog = argv[0];
Opterr = 1;
while( (n = Getopt(argc, argv, "dut")) != EOF ){
switch(n){
default: usage(); break;
case 'u': use_udp = !use_udp; break;
case 't': use_tcp = !use_tcp; break;
case 'd': debug = 1; break;
}
}
i = argc - Optind;
if( i > 1 ) usage();
if( i == 1 ){
portname = argv[Optind];
n = atoi( portname );
if( n <= 0 ){
servent = getservbyname( portname, "udp" );
if( servent ){
n = ntohs( servent->s_port );
}
}
if( n <= 0 ){
FPRINTF( STDERR, "udp_open: bad port number '%s'\n",portname );
usage();
}
port_num = n;
}
if( !use_tcp && !use_udp ) use_udp = 1;
if( debug ){
FPRINTF(STDERR,"monitor: udp %d, tcp %d, port %d\n",
use_udp, use_tcp, port_num );
}
max_port = 0;
FD_ZERO( &readfds );
if( use_udp && (udp_fd = udp_open( port_num )) >= 0){
if( debug ) FPRINTF(STDERR,"monitor: udp port %d\n", udp_fd );
FD_SET(udp_fd, &readfds);
if( udp_fd >= max_port ) max_port = udp_fd+1;
}
if( use_tcp && (tcp_fd = tcp_open( port_num )) >= 0){
if( debug ) FPRINTF(STDERR,"monitor: tcp port %d\n", tcp_fd );
FD_SET(tcp_fd, &readfds);
if( tcp_fd >= max_port ) max_port = tcp_fd+1;
}
if( debug ){
FPRINTF(STDERR,"monitor: max_port %d\n", max_port );
for( i = 0; i < max_port; ++i ){
if( FD_ISSET(i, &readfds) ){
FPRINTF(STDERR,"monitor: initial on %d\n", i );
}
}
}
while(1){
FD_ZERO( &testfds );
for( i = 0; i < max_port; ++i ){
if( FD_ISSET(i, &readfds) ){
if( debug ) FPRINTF(STDERR,"monitor: waiting on %d\n", i );
FD_SET(i, &testfds);
}
}
if( debug ) FPRINTF(STDERR,"monitor: starting wait, max %d\n", i );
n = select( i,
FD_SET_FIX((fd_set *))&testfds,
FD_SET_FIX((fd_set *))0, FD_SET_FIX((fd_set *))0,
(struct timeval *)0 );
err = errno;
if( debug ) FPRINTF(STDERR,"monitor: select returned %d\n", n );
if( n < 0 ){
FPRINTF( STDERR, "select error - %s\n", Errormsg(errno) );
if( err != EINTR ) break;
}
if( n > 0 ) for( i = 0; i < max_port; ++i ){
if( FD_ISSET(i, &testfds) ){
if( debug ) FPRINTF(STDERR,"monitor: input on %d\n", i );
if( i == tcp_fd ){
#if defined(HAVE_SOCKLEN_T)
socklen_t len;
#else
int len;
#endif
struct sockaddr_in sinaddr;
len = sizeof( sinaddr );
i = accept( tcp_fd, (struct sockaddr *)&sinaddr, &len );
if( i < 0 ){
FPRINTF( STDERR, "accept error - %s\n",
Errormsg(errno) );
continue;
}
FPRINTF( STDOUT, "connection from %s\n",
inet_ntoa( sinaddr.sin_addr ) );
if( i >= max_port ) max_port = i+1;
FD_SET(i, &readfds);
} else {
c = read( i, buffer, sizeof(buffer)-1 );
if( c == 0 ){
/* closed connection */
FPRINTF(STDOUT, "closed connection %d\n", i );
close( i );
FD_CLR(i, &readfds );
Clear_buffer(i);
} else if( c > 0 ){
buffer[c] = 0;
if(debug)FPRINTF( STDOUT, "recv port %d: %s\n", i, buffer );
Add_buffer(i);
in = Save_outbuf_len( i, buffer, c );
while( (s = safestrchr(in->buffer,'\n')) ){
*s++ = 0;
Decode(in->buffer);
memmove(in->buffer,s, safestrlen(s)+1 );
in->len = safestrlen(in->buffer);
}
} else {
FPRINTF( STDERR, "read error - %s\n",
Errormsg(errno) );
close( i );
FD_CLR(i, &readfds );
}
}
}
}
}
return(0);
}
VOID
Client(
char* Server,
char* Pipe
)
{
HANDLE *Connection;
DWORD tid;
MyStdInp=GetStdHandle(STD_INPUT_HANDLE);
MyStdOut=GetStdHandle(STD_OUTPUT_HANDLE);
WRITEF((VBuff,"**************************************\n"));
WRITEF((VBuff,"*********** REMOTE ************\n"));
WRITEF((VBuff,"*********** CLIENT ************\n"));
WRITEF((VBuff,"**************************************\n"));
if ((Connection=EstablishSession(Server,Pipe))==NULL)
return;
ReadPipe=Connection[0];
WritePipe=Connection[1];
SetConsoleCtrlHandler((PHANDLER_ROUTINE)Mych,TRUE);
// Start Thread For Server --> Client Flow
if ((iothreads[0]=CreateThread((LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
(DWORD)0, // Use same stack size.
(LPTHREAD_START_ROUTINE)GetServerOut, // Thread procedure.
(LPVOID)NULL, // Parameter to pass.
(DWORD)0, // Run immediately.
(LPDWORD)&tid))==NULL) // Thread identifier.
{
Errormsg("Could Not Create rwSrv2Cl Thread");
return;
}
//
// Start Thread for Client --> Server Flow
//
if ((iothreads[1]=CreateThread((LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
(DWORD)0, // Use same stack size.
(LPTHREAD_START_ROUTINE)SendServerInp, // Thread procedure.
(LPVOID)NULL, // Parameter to pass.
(DWORD)0, // Run immediately.
(LPDWORD)&tid))==NULL) // Thread identifier.
{
Errormsg("Could Not Create rwSrv2Cl Thread");
return;
}
WaitForMultipleObjects(2,iothreads,FALSE,INFINITE);
TerminateThread(iothreads[0],1);
TerminateThread(iothreads[1],1);
WRITEF((VBuff,"*** SESSION OVER ***\n"));
}
VOID
SendMyInfo(
PHANDLE pipeH
)
{
HANDLE rPipe=pipeH[0];
HANDLE wPipe=pipeH[1];
DWORD hostlen=HOSTNAMELEN-1;
WORD BytesToSend=sizeof(SESSION_STARTUPINFO);
DWORD tmp;
SESSION_STARTUPINFO ssi;
SESSION_STARTREPLY ssr;
DWORD BytesToRead;
char *buff;
ssi.Size=BytesToSend;
ssi.Version=VERSION;
GetComputerName((char *)ssi.ClientName,&hostlen);
ssi.LinesToSend=LinesToSend;
ssi.Flag=ClientToServerFlag;
{
DWORD NewCode=MAGICNUMBER;
char Name[15];
strcpy(Name,(char *)ssi.ClientName);
memcpy(&Name[11],(char *)&NewCode,sizeof(NewCode));
WriteFile(wPipe,(char *)Name,HOSTNAMELEN-1,&tmp,NULL);
ReadFile(rPipe ,(char *)&ssr.MagicNumber,sizeof(ssr.MagicNumber),&tmp,NULL);
if (ssr.MagicNumber!=MAGICNUMBER)
{
WRITEF((VBuff,"WARNING-YOU ARE CONNECTED TO AN OLD REMOTE SERVER\n"));
WriteFile(MyStdOut,(char *)&ssr.MagicNumber,sizeof(ssr.MagicNumber),&tmp,NULL);
return;
}
//Get Rest of the info-its not the old server
ReadFixBytes(rPipe,(char *)&ssr.Size,sizeof(ssr.Size),0);
ReadFixBytes(rPipe,(char *)&ssr.FileSize,sizeof(ssr)-sizeof(ssr.FileSize)-sizeof(ssr.MagicNumber),0);
}
if (!WriteFile(wPipe,(char *)&ssi,BytesToSend,&tmp,NULL))
{
Errormsg("INFO Send Error");
return;
}
BytesToRead=MINIMUM(ssr.FileSize,ssi.LinesToSend*CHARS_PER_LINE);
buff=calloc(BytesToRead+1,1);
if (buff!=NULL)
{
DWORD bytesread=0;
ReadFile(rPipe,buff,BytesToRead,&bytesread,NULL);
WriteFile(MyStdOut,buff,bytesread,&tmp,NULL);
free(buff);
}
}
