E_COUNTRY tctrl_ip_to_country(char* ip) {
int err;
//Buffer to construct commit string
char country[2];
char buf[128], *tmp, *tmp2;
err = strlen(ip);
if (err>100) {
return COUNTRY_ERROR;
}
sprintf(buf, "getinfo ip-to-country/%s", ip);
err = send_request(buf);
if (err<0) {
return COUNTRY_ERROR;
}
err = recv_request(&tmp);
if (err<0) {
free(tmp);
return COUNTRY_ERROR;
}
err = check_str_err(tmp);
if (err<0) {
free(tmp);
return COUNTRY_ERROR;
}
//man rindex
tmp2 = rindex(tmp, '=')+1;
strncpy(country, tmp2, 2);
//SWITCH CASE COUNTRY
printf("%s\n", country);
free(tmp);
return country_to_enum(country);
}
int tctrl_authenticate(char* password) {
int err;
size_t strlength;
//Buffer to construct commit string
char buf[128], *tmp;
//Length for password, avoid bufferoverflow
strlength = strlen(password);
if (strlength>100) {
return -1;
}
//Build cmd string
sprintf(buf, "authenticate \"%s\"", password);
err = send_request(buf);
if (err<0) {
return -1;
}
err = recv_request(&tmp);
if (err<0) {
return -1;
}
err = check_str_err(tmp);
if (err<0) {
return -1;
}
free(tmp);
return 0;
}
void child_handle(int fds)
{
int flag=1;
int newfd=-1;
while(1)
{
recv_fd(fds,&newfd);
recv_request(newfd);
write(fds,&flag,4);
}
}
void
process_requests()
{
float temp_rate;
if (debug) open_debug_file();
while (1) {
recv_request();
switch (netperf_request.content.request_type) {
case DEBUG_ON:
netperf_response.content.response_type = DEBUG_OK;
/* dump_request already present in recv_request; redundant? */
if (!debug) {
debug++;
open_debug_file();
dump_request();
}
send_response();
break;
case DEBUG_OFF:
if (debug)
debug--;
netperf_response.content.response_type = DEBUG_OK;
send_response();
/* +SAF why??? */
if (!debug)
{
fclose(where);
#if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
/* For Unix: reopen the debug write file descriptor to "/dev/null" */
/* and redirect stdout to it. */
fflush (stdout);
where = fopen ("/dev/null", "w");
if (where == NULL)
{
perror ("netserver: reopening debug fp for writing: /dev/null");
exit (1);
}
if (close (STDOUT_FILENO) == -1)
{
perror ("netserver: closing stdout file descriptor");
exit (1);
}
if (dup (fileno (where)) == -1)
{
perror ("netserver: duplicate /dev/null write file descr. to stdout");
exit (1);
}
#endif /* !WIN32 !MPE !__VMS */
}
break;
case CPU_CALIBRATE:
netperf_response.content.response_type = CPU_CALIBRATE;
temp_rate = calibrate_local_cpu(0.0);
bcopy((char *)&temp_rate,
(char *)netperf_response.content.test_specific_data,
sizeof(temp_rate));
bcopy((char *)&lib_num_loc_cpus,
(char *)netperf_response.content.test_specific_data + sizeof(temp_rate),
sizeof(lib_num_loc_cpus));
if (debug) {
fprintf(where,"netserver: sending CPU information:");
fprintf(where,"rate is %g num cpu %d\n",temp_rate,lib_num_loc_cpus);
fflush(where);
}
/* we need the cpu_start, cpu_stop in the looper case to kill the */
/* child proceses raj 7/95 */
#ifdef USE_LOOPER
cpu_start(1);
cpu_stop(1,&temp_rate);
#endif /* USE_LOOPER */
send_response();
break;
case DO_TCP_STREAM:
recv_tcp_stream();
break;
case DO_TCP_MAERTS:
recv_tcp_maerts();
break;
case DO_TCP_RR:
recv_tcp_rr();
break;
case DO_TCP_CRR:
recv_tcp_conn_rr();
break;
case DO_TCP_CC:
recv_tcp_cc();
break;
#ifdef DO_1644
case DO_TCP_TRR:
recv_tcp_tran_rr();
break;
#endif /* DO_1644 */
#ifdef DO_NBRR
case DO_TCP_NBRR:
recv_tcp_nbrr();
break;
#endif /* DO_NBRR */
case DO_UDP_STREAM:
recv_udp_stream();
break;
case DO_UDP_RR:
recv_udp_rr();
break;
#ifdef WANT_DLPI
case DO_DLPI_CO_RR:
recv_dlpi_co_rr();
break;
case DO_DLPI_CL_RR:
recv_dlpi_cl_rr();
break;
case DO_DLPI_CO_STREAM:
recv_dlpi_co_stream();
break;
case DO_DLPI_CL_STREAM:
recv_dlpi_cl_stream();
break;
#endif /* WANT_DLPI */
#ifdef WANT_UNIX
case DO_STREAM_STREAM:
recv_stream_stream();
break;
case DO_STREAM_RR:
recv_stream_rr();
break;
case DO_DG_STREAM:
recv_dg_stream();
break;
case DO_DG_RR:
recv_dg_rr();
break;
#endif /* WANT_UNIX */
#ifdef WANT_XTI
case DO_XTI_TCP_STREAM:
recv_xti_tcp_stream();
break;
case DO_XTI_TCP_RR:
recv_xti_tcp_rr();
break;
case DO_XTI_UDP_STREAM:
recv_xti_udp_stream();
break;
case DO_XTI_UDP_RR:
recv_xti_udp_rr();
break;
#endif /* WANT_XTI */
#ifdef WANT_SCTP
case DO_SCTP_STREAM:
recv_sctp_stream();
break;
case DO_SCTP_STREAM_MANY:
recv_sctp_stream_1toMany();
break;
case DO_SCTP_RR:
recv_sctp_rr();
break;
case DO_SCTP_RR_MANY:
recv_sctp_rr_1toMany();
break;
#endif
#ifdef WANT_SDP
case DO_SDP_STREAM:
recv_sdp_stream();
break;
case DO_SDP_MAERTS:
recv_sdp_maerts();
break;
case DO_SDP_RR:
recv_sdp_rr();
break;
#endif
default:
fprintf(where,"unknown test number %d\n",
netperf_request.content.request_type);
fflush(where);
netperf_response.content.serv_errno=998;
send_response();
break;
}
}
}
void
process_requests()
{
float temp_rate;
if (debug) {
fprintf(where,
"%s: enter\n",
__FUNCTION__);
fflush(where);
}
/* if the netserver was started with a passphrase, look for it in
the first request to arrive. if there is no passphrase in the
first request we will end-up dumping the control connection. raj
2012-01-23 */
if ((passphrase != NULL) && (recv_passphrase()))
return;
while (1) {
if (recv_request() <= 0) {
close(server_sock);
return;
}
switch (netperf_request.content.request_type) {
case DEBUG_ON:
netperf_response.content.response_type = DEBUG_OK;
if (!suppress_debug) {
debug++;
if (debug == 1) {
/* we just flipped-on debugging, dump the request because
recv_request/recv_request_n will not have dumped it as its
dump_request() call is conditional on debug being set. raj
2011-07-08 */
dump_request();
}
}
send_response();
break;
case DEBUG_OFF:
if (debug)
debug--;
netperf_response.content.response_type = DEBUG_OK;
send_response();
/* we used to take the trouble to close the debug file, but SAF
asked a good question when he asked "Why?" and since I cannot
think of a good reason, I have removed the code. raj
2011-07-08 */
break;
case DO_SYSINFO:
{
netperf_response.content.response_type = SYSINFO_RESPONSE;
snprintf((char *)netperf_response.content.test_specific_data,
sizeof(netperf_response.content.test_specific_data),
"%c%s%c%s%c%s%c%s",
',',
"Deprecated",
','
, "Deprecated",
',',
"Deprecated",
',',
"Deprecated");
send_response_n(0);
break;
}
case CPU_CALIBRATE:
netperf_response.content.response_type = CPU_CALIBRATE;
temp_rate = calibrate_local_cpu(0.0);
bcopy((char *)&temp_rate,
(char *)netperf_response.content.test_specific_data,
sizeof(temp_rate));
bcopy((char *)&lib_num_loc_cpus,
(char *)netperf_response.content.test_specific_data +
sizeof(temp_rate),
sizeof(lib_num_loc_cpus));
if (debug) {
fprintf(where,
"netserver: sending CPU information: rate is %g num cpu %d\n",
temp_rate,
lib_num_loc_cpus);
fflush(where);
}
/* we need the cpu_start, cpu_stop in the looper case to kill
the child proceses raj 7/95 */
#ifdef USE_LOOPER
cpu_start(1);
cpu_stop(1,&temp_rate);
#endif /* USE_LOOPER */
send_response();
break;
case DO_TCP_STREAM:
recv_tcp_stream();
break;
case DO_TCP_MAERTS:
recv_tcp_maerts();
break;
case DO_TCP_RR:
recv_tcp_rr();
break;
case DO_TCP_CRR:
recv_tcp_conn_rr();
break;
case DO_TCP_CC:
recv_tcp_cc();
break;
#ifdef DO_1644
case DO_TCP_TRR:
recv_tcp_tran_rr();
break;
#endif /* DO_1644 */
#ifdef DO_NBRR
case DO_TCP_NBRR:
recv_tcp_nbrr();
break;
#endif /* DO_NBRR */
case DO_UDP_STREAM:
recv_udp_stream();
break;
case DO_UDP_RR:
recv_udp_rr();
break;
#ifdef WANT_DLPI
case DO_DLPI_CO_RR:
recv_dlpi_co_rr();
break;
case DO_DLPI_CL_RR:
recv_dlpi_cl_rr();
break;
case DO_DLPI_CO_STREAM:
recv_dlpi_co_stream();
break;
case DO_DLPI_CL_STREAM:
recv_dlpi_cl_stream();
break;
#endif /* WANT_DLPI */
#ifdef WANT_UNIX
case DO_STREAM_STREAM:
recv_stream_stream();
break;
case DO_STREAM_RR:
recv_stream_rr();
break;
case DO_DG_STREAM:
recv_dg_stream();
break;
case DO_DG_RR:
recv_dg_rr();
break;
#endif /* WANT_UNIX */
#ifdef WANT_XTI
case DO_XTI_TCP_STREAM:
recv_xti_tcp_stream();
break;
case DO_XTI_TCP_RR:
recv_xti_tcp_rr();
break;
case DO_XTI_UDP_STREAM:
recv_xti_udp_stream();
break;
case DO_XTI_UDP_RR:
recv_xti_udp_rr();
break;
#endif /* WANT_XTI */
#ifdef WANT_SCTP
case DO_SCTP_STREAM:
recv_sctp_stream();
break;
case DO_SCTP_STREAM_MANY:
recv_sctp_stream_1toMany();
break;
case DO_SCTP_RR:
recv_sctp_rr();
break;
case DO_SCTP_RR_MANY:
recv_sctp_rr_1toMany();
break;
#endif
#ifdef WANT_SDP
case DO_SDP_STREAM:
recv_sdp_stream();
break;
case DO_SDP_MAERTS:
recv_sdp_maerts();
break;
case DO_SDP_RR:
recv_sdp_rr();
break;
#endif
#ifdef WANT_OMNI
case DO_OMNI:
recv_omni();
break;
#endif
case PASSPHRASE:
if (debug) {
fprintf(where,"Ignoring an unexpected passphrase control message\n");
fflush(where);
}
break;
default:
fprintf(where,"unknown test number %d\n",
netperf_request.content.request_type);
fflush(where);
netperf_response.content.serv_errno=998;
send_response();
break;
}
}
}
inline
void operator()( const VectorType & v ) const
{
typedef typename VectorType::value_type scalar_type ;
const Teuchos::MpiComm<int> & teuchos_mpi_comm = dynamic_cast< const Teuchos::MpiComm<int> & >( *comm );
MPI_Comm mpi_comm = * teuchos_mpi_comm.getRawMpiComm();
const int mpi_tag = 42 ;
const unsigned vchunk = v.dimension_1();
// Subvector for receives
const std::pair<unsigned,unsigned> recv_range( count_owned , count_owned + count_receive );
const VectorType recv_vector = Kokkos::subview< VectorType >( v , recv_range );
std::vector< MPI_Request > recv_request( recv_msg.dimension_0() , MPI_REQUEST_NULL );
{ // Post receives
scalar_type * ptr =
ReceiveInPlace ? recv_vector.ptr_on_device() : host_recv_buffer.ptr_on_device();
for ( size_t i = 0 ; i < recv_msg.dimension_0() ; ++i ) {
const int proc = recv_msg(i,0);
const int count = recv_msg(i,1) * vchunk ;
MPI_Irecv( ptr , count * sizeof(scalar_type) , MPI_BYTE ,
proc , mpi_tag , mpi_comm , & recv_request[i] );
ptr += count ;
}
}
MPI_Barrier( mpi_comm );
{ // Pack and send
const Pack pack( send_nodeid , v , send_buffer );
Kokkos::deep_copy( host_send_buffer , send_buffer );
scalar_type * ptr = host_send_buffer.ptr_on_device();
for ( size_t i = 0 ; i < send_msg.dimension_0() ; ++i ) {
const int proc = send_msg(i,0);
const int count = send_msg(i,1) * vchunk ;
// MPI_Ssend blocks until
// (1) a receive is matched for the message and
// (2) the send buffer can be re-used.
//
// It is suggested that MPI_Ssend will have the best performance:
// http://www.mcs.anl.gov/research/projects/mpi/sendmode.html .
MPI_Ssend( ptr ,
count * sizeof(scalar_type) , MPI_BYTE ,
proc , mpi_tag , mpi_comm );
ptr += count ;
}
}
// Wait for receives and verify:
for ( size_t i = 0 ; i < recv_msg.dimension_0() ; ++i ) {
MPI_Status recv_status ;
int recv_which = 0 ;
int recv_size = 0 ;
MPI_Waitany( recv_msg.dimension_0() , & recv_request[0] , & recv_which , & recv_status );
const int recv_proc = recv_status.MPI_SOURCE ;
MPI_Get_count( & recv_status , MPI_BYTE , & recv_size );
// Verify message properly received:
const int expected_proc = recv_msg(recv_which,0);
const int expected_size = recv_msg(recv_which,1) * vchunk * sizeof(scalar_type);
if ( ( expected_proc != recv_proc ) ||
( expected_size != recv_size ) ) {
int local_rank = 0 ;
MPI_Comm_rank( mpi_comm , & local_rank );
std::ostringstream msg ;
msg << "VectorImport error:"
<< " P" << local_rank
<< " received from P" << recv_proc
<< " size " << recv_size
<< " expected " << expected_size
<< " from P" << expected_proc ;
throw std::runtime_error( msg.str() );
}
}
// Copy received data to device memory.
if ( ! ReceiveInPlace ) { Kokkos::deep_copy( recv_vector , host_recv_buffer ); }
}
//--------------------------------------------------------------------------
bool rpc_debmod_t::open_remote(
const char *hostname,
int port_number,
const char *password)
{
rpc_packet_t *rp = NULL;
network_error_code = 0;
irs = init_client_irs(hostname, port_number);
if ( irs == NULL )
{
FAILURE:
if ( rp != NULL )
qfree(rp);
term_irs();
return false;
}
rp = recv_request();
if ( rp == NULL || rp->code != RPC_OPEN ) // is this an ida debugger server?
{
rpc_client_t::dwarning("ICON ERROR\nAUTOHIDE NONE\n"
"Bogus or irresponsive remote server");
goto FAILURE;
}
const uchar *answer = (uchar *)(rp+1);
const uchar *end = answer + rp->length;
int version = extract_long(&answer, end);
int remote_debugger_id = extract_long(&answer, end);
int easize = extract_long(&answer, end);
qstring errstr;
if ( version != IDD_INTERFACE_VERSION )
errstr.sprnt("protocol version is %d, expected %d", version, IDD_INTERFACE_VERSION);
else if ( remote_debugger_id != debugger.id )
errstr.sprnt("debugger id is %d, expected %d (%s)", remote_debugger_id, debugger.id, debugger.name);
else if ( easize != get_expected_addrsize() )
errstr.sprnt("address size is %d bytes, expected %d", easize, inf.is_64bit() ? 8 : 4);
if ( !errstr.empty() )
{
bytevec_t req = prepare_rpc_packet(RPC_OK);
append_dd(req, false);
send_request(req);
warning("ICON ERROR\nAUTOHIDE NONE\n"
"Incompatible debugging server:\n"
"%s\n", errstr.c_str());
goto FAILURE;
}
qfree(rp);
bytevec_t req = prepare_rpc_packet(RPC_OK);
append_dd(req, true);
append_str(req, password);
send_request(req);
rp = recv_request();
if ( rp == NULL || rp->code != RPC_OK )
goto FAILURE;
answer = (uchar *)(rp+1);
end = answer + rp->length;
bool password_ok = extract_long(&answer, end) != 0;
if ( !password_ok ) // is this an ida debugger server?
{
warning("ICON ERROR\nAUTOHIDE NONE\n"
"Bad password");
goto FAILURE;
}
qfree(rp);
return true;
}
void
process_requests()
{
float temp_rate;
while (1) {
if (recv_request() == 0)
return;
if (debug)
dump_request();
switch (netperf_request.content.request_type) {
case DEBUG_ON:
netperf_response.content.response_type = DEBUG_OK;
if (!debug)
debug++;
dump_request();
send_response();
break;
case DEBUG_OFF:
if (debug)
debug--;
netperf_response.content.response_type = DEBUG_OK;
fclose(where);
send_response();
break;
case CPU_CALIBRATE:
netperf_response.content.response_type = CPU_CALIBRATE;
temp_rate = calibrate_local_cpu(0.0);
bcopy((char *)&temp_rate,
(char *)netperf_response.content.test_specific_data,
sizeof(temp_rate));
if (debug) {
fprintf(where,"netserver: sending CPU information:");
fprintf(where,"rate is %g\n",temp_rate);
fflush(where);
}
/* we need the cpu_start, cpu_stop in the looper case to kill the */
/* child proceses raj 7/95 */
cpu_start(1);
cpu_stop(1,&temp_rate);
send_response();
break;
case DO_TCP_STREAM:
recv_tcp_stream();
break;
case DO_TCP_RR:
recv_tcp_rr();
break;
case DO_TCP_CRR:
recv_tcp_conn_rr();
break;
case DO_TCP_CC:
recv_tcp_cc();
break;
#ifdef DO_1644
case DO_TCP_TRR:
recv_tcp_tran_rr();
break;
#endif /* DO_1644 */
#ifdef DO_NBRR
case DO_TCP_NBRR:
recv_tcp_nbrr();
break;
#endif /* DO_NBRR */
case DO_UDP_STREAM:
recv_udp_stream();
break;
case DO_UDP_RR:
recv_udp_rr();
break;
#ifdef DO_DLPI
case DO_DLPI_CO_RR:
recv_dlpi_co_rr();
break;
case DO_DLPI_CL_RR:
recv_dlpi_cl_rr();
break;
case DO_DLPI_CO_STREAM:
recv_dlpi_co_stream();
break;
case DO_DLPI_CL_STREAM:
recv_dlpi_cl_stream();
break;
#endif /* DO_DLPI */
#ifdef DO_UNIX
case DO_STREAM_STREAM:
recv_stream_stream();
break;
case DO_STREAM_RR:
recv_stream_rr();
break;
case DO_DG_STREAM:
recv_dg_stream();
break;
case DO_DG_RR:
recv_dg_rr();
break;
#endif /* DO_UNIX */
#ifdef DO_FORE
case DO_FORE_STREAM:
recv_fore_stream();
break;
case DO_FORE_RR:
recv_fore_rr();
break;
#endif /* DO_FORE */
#ifdef DO_HIPPI
case DO_HIPPI_STREAM:
recv_hippi_stream();
break;
case DO_HIPPI_RR:
recv_hippi_rr();
break;
#endif /* DO_HIPPI */
#ifdef DO_XTI
case DO_XTI_TCP_STREAM:
recv_xti_tcp_stream();
break;
case DO_XTI_TCP_RR:
recv_xti_tcp_rr();
break;
case DO_XTI_UDP_STREAM:
recv_xti_udp_stream();
break;
case DO_XTI_UDP_RR:
recv_xti_udp_rr();
break;
#endif /* DO_XTI */
#ifdef DO_LWP
case DO_LWPSTR_STREAM:
recv_lwpstr_stream();
break;
case DO_LWPSTR_RR:
recv_lwpstr_rr();
break;
case DO_LWPDG_STREAM:
recv_lwpdg_stream();
break;
case DO_LWPDG_RR:
recv_lwpdg_rr();
break;
#endif /* DO_LWP */
#ifdef DO_IPV6
case DO_TCPIPV6_STREAM:
recv_tcpipv6_stream();
break;
case DO_TCPIPV6_RR:
recv_tcpipv6_rr();
break;
case DO_TCPIPV6_CRR:
recv_tcpipv6_conn_rr();
break;
case DO_UDPIPV6_STREAM:
recv_udpipv6_stream();
break;
case DO_UDPIPV6_RR:
recv_udpipv6_rr();
break;
#endif /* DO_IPV6 */
default:
fprintf(where,"unknown test number %d\n",
netperf_request.content.request_type);
fflush(where);
netperf_response.content.serv_errno=998;
send_response();
break;
}
}
}
/** @fn fcserver_ret_t fcserver_process (fcserver_t* server, int clientSocket)
* @brief Speak with the client
*
* @param[in] server structure, where the client should be put in
* @param[in] client the connected client to talk to.
* @return status
*/
static fcserver_ret_t process_client(fcserver_t* server, fcclient_t* client)
{
int n, offset = 0;
int type=-1;
int length = 0;
int write_offset = 0;
/* FIXME the server->tmpMem should probalby exists for each client
* (even if only one client, connected to the wall can generate the huge packets) */
n = hwal_socket_tcp_read(client->clientsocket,
(server->tmpMem + server->reading_offset),
(server->tmpMemSize - server->reading_offset));
/*FIXME try to check if client is still connected FCSERVER_RET_CLOSED */
/* First check, if the Client has something to say */
if (n == -1)
{
/* no new packet found on the network */
return FCSERVER_RET_NOTHINGNEW;
}
else if (n == 0)
{
return FCSERVER_RET_CLOSED;
}
else if (n < HEADER_LENGTH)
{
DEBUG_PLINE("Error : Network read error");
return FCSERVER_RET_IOERR;
}
offset = get_header(server->tmpMem, 0, &type, &length);
if (offset == -1)
{
DEBUG_PLINE("Error : Could not analyze header");
return FCSERVER_RET_IOERR;
}
/* Add the already extracted bytes to the new ones */
n += server->reading_offset;
DEBUG_PLINE("New Header typ: %d length of information: %d [fetched is %d byte from the network]",type,length, n);
if (length > n)
{
server->reading_offset = n;
DEBUG_PLINE("Update offset to %d", server->reading_offset);
}
else
{
/* reset the fragment detection for packets */
server->reading_offset = 0;
/* Decode the information */
switch (type)
{
case SNIPTYPE_REQUEST:
{
char *color;
int seqId;
int meta_offset;
int meta_length;
int frames_per_second, width, heigth;
char *generator_name;
char *generator_version;
offset = recv_request(server->tmpMem, offset, &color, &seqId, &meta_offset, &meta_length);
if (offset == -1) {
DEBUG_PLINE("recv_request Faild!");
} else {
DEBUG_PLINE("Parse Request, Color: %s, seqId: %d",color,seqId);
}
offset = parse_metadata(server->tmpMem,meta_offset,&frames_per_second,
&width, &heigth, &generator_name, &generator_version);
if (offset == -1) {
DEBUG_PLINE("parse Metadata Faild!");
return -1;
} else {
DEBUG_PLINE("Metadata, fps: %d, width: %d, height: %d, gen._name: %s, gen._version: %s",
frames_per_second,width,heigth,generator_name,generator_version);
}
/* allocate some memory for answering */
uint8_t *output = hwal_malloc(BUFFERSIZE_OUTPUT); hwal_memset(output, 0, BUFFERSIZE_OUTPUT);
uint8_t *buffer = hwal_malloc(BUFFERSIZE_SENDINGBUFFER); hwal_memset(output, 0, BUFFERSIZE_SENDINGBUFFER);
/* Verify , if the client has the correct resolution */
if (server->width == width && server->height == heigth)
{
client->clientstatus = FCCLIENT_STATUS_WAITING;
/* Send the client an acknowledgement (ACK) */
write_offset = send_ack(buffer, write_offset);
DEBUG_PLINE("ACK Request send");
}
else
{
uint8_t buffer[BUFFERSIZE_SENDINGBUFFER];
/* Inform the client with an error message */
char descr[] = "Wrong Screen resolution";
DEBUG_PLINE("Error while requesting: '%s'", descr);
write_offset = send_error(buffer, write_offset, FCSERVER_ERR_RESOLUTION, descr);
}
/* send the corresponding message: Success or error */
add_header(buffer, output, write_offset);
hwal_socket_tcp_write(client->clientsocket, output, write_offset+HEADER_LENGTH);
hwal_free(buffer);
hwal_free(output);
/* Free all resources needed for sending */
hwal_free(color);
hwal_free(generator_name);
hwal_free(generator_version);
break;
}
case SNIPTYPE_FRAME:
{
int x, y, red, green, blue;
int frame_length;
int frame_offset, frame_offset_start;
int index;
offset = recv_frame(server->tmpMem, offset, &frame_offset, &frame_length);
if (offset == -1) {
DEBUG_PLINE("recv_frame Faild!");
} else {
DEBUG_PLINE("Parse Frame, frame_length: %d",frame_length);
}
frame_offset_start = frame_offset;
do {
frame_offset = frame_parse_pixel(server->tmpMem,frame_offset, &red, &green, &blue, &x, &y);
index = (((x * server->width) + y) * 3);
server->imageBuffer[index + 0] = red;
server->imageBuffer[index + 1] = green;
server->imageBuffer[index + 2] = blue;
} while (frame_offset < (frame_offset_start+frame_length));
if (server->onNewImage > 0)
{
server->onNewImage(server->imageBuffer, server->width, server->height);
}
break;
}
case SNIPTYPE_INFOREQUEST:
{
uint8_t *output = hwal_malloc(BUFFERSIZE_OUTPUT); hwal_memset(output, 0, BUFFERSIZE_OUTPUT);
uint8_t *buffer = hwal_malloc(BUFFERSIZE_SENDINGBUFFER); hwal_memset(output, 0, BUFFERSIZE_SENDINGBUFFER);
uint8_t *meta = hwal_malloc(BUFFERSIZE_SENDINGBUFFER); hwal_memset(output, 0, BUFFERSIZE_SENDINGBUFFER);
int offset_meta = create_metadata(meta, 0, FCSERVER_DEFAULT_FPS,
server->width, server->height,
FCSERVER_DEFAULT_NAME,
FCSERVER_DEFAULT_VERSION);
write_offset = send_infoanswer(buffer, write_offset, meta, offset_meta);
add_header(buffer, output, write_offset);
hwal_socket_tcp_write(client->clientsocket, output, write_offset+HEADER_LENGTH);
DEBUG_PLINE("Answered %dx%d pixel (%d fps) for '%s' on version '%s'",server->width, server->height, FCSERVER_DEFAULT_FPS,
FCSERVER_DEFAULT_NAME,
FCSERVER_DEFAULT_VERSION);
hwal_free(meta);
hwal_free(buffer);
hwal_free(output);
}
break;
case SNIPTYPE_PING:
case SNIPTYPE_PONG:
case SNIPTYPE_ERROR:
case SNIPTYPE_START:
case SNIPTYPE_ACK:
case SNIPTYPE_NACK:
case SNIPTYPE_TIMEOUT:
case SNIPTYPE_ABORT:
case SNIPTYPE_EOS:
case SNIPTYPE_INFOANSWER:
default:
DEBUG_PLINE("%d is not implemented",type);
break;
}
}
return FCSERVER_RET_OK;
}
void
process_requests()
{
float temp_rate;
while (1) {
recv_request();
switch (netperf_request.content.request_type) {
case DEBUG_ON:
netperf_response.content.response_type = DEBUG_OK;
/* dump_request already present in recv_request; redundant? */
if (!debug) {
debug++;
dump_request();
}
send_response();
break;
case DEBUG_OFF:
if (debug)
debug--;
netperf_response.content.response_type = DEBUG_OK;
send_response();
/* +SAF why??? */
if (!debug)
fclose(where);
break;
case CPU_CALIBRATE:
netperf_response.content.response_type = CPU_CALIBRATE;
temp_rate = calibrate_local_cpu(0.0);
bcopy((char *)&temp_rate,
(char *)netperf_response.content.test_specific_data,
sizeof(temp_rate));
if (debug) {
fprintf(where,"netserver: sending CPU information:");
fprintf(where,"rate is %g\n",temp_rate);
fflush(where);
}
/* we need the cpu_start, cpu_stop in the looper case to kill the */
/* child proceses raj 7/95 */
#ifdef USE_LOOPER
cpu_start(1);
cpu_stop(1,&temp_rate);
#endif /* USE_LOOPER */
send_response();
break;
case DO_TCP_STREAM:
recv_tcp_stream();
break;
case DO_TCP_MAERTS:
recv_tcp_maerts();
break;
case DO_TCP_RR:
recv_tcp_rr();
break;
case DO_TCP_CRR:
recv_tcp_conn_rr();
break;
case DO_TCP_CC:
recv_tcp_cc();
break;
#ifdef DO_1644
case DO_TCP_TRR:
recv_tcp_tran_rr();
break;
#endif /* DO_1644 */
#ifdef DO_NBRR
case DO_TCP_NBRR:
recv_tcp_nbrr();
break;
#endif /* DO_NBRR */
case DO_UDP_STREAM:
recv_udp_stream();
break;
case DO_UDP_RR:
recv_udp_rr();
break;
#ifdef WANT_DLPI
case DO_DLPI_CO_RR:
recv_dlpi_co_rr();
break;
case DO_DLPI_CL_RR:
recv_dlpi_cl_rr();
break;
case DO_DLPI_CO_STREAM:
recv_dlpi_co_stream();
break;
case DO_DLPI_CL_STREAM:
recv_dlpi_cl_stream();
break;
#endif /* WANT_DLPI */
#ifdef WANT_UNIX
case DO_STREAM_STREAM:
recv_stream_stream();
break;
case DO_STREAM_RR:
recv_stream_rr();
break;
case DO_DG_STREAM:
recv_dg_stream();
break;
case DO_DG_RR:
recv_dg_rr();
break;
#endif /* WANT_UNIX */
#ifdef WANT_XTI
case DO_XTI_TCP_STREAM:
recv_xti_tcp_stream();
break;
case DO_XTI_TCP_RR:
recv_xti_tcp_rr();
break;
case DO_XTI_UDP_STREAM:
recv_xti_udp_stream();
break;
case DO_XTI_UDP_RR:
recv_xti_udp_rr();
break;
#endif /* WANT_XTI */
#ifdef DO_DNS
case DO_DNS_RR:
recv_dns_rr();
break;
#endif /* DO_DNS */
#ifdef WANT_SCTP
case DO_SCTP_STREAM:
recv_sctp_stream();
break;
case DO_SCTP_STREAM_MANY:
recv_sctp_stream_1toMany();
break;
case DO_SCTP_RR:
recv_sctp_rr();
break;
case DO_SCTP_RR_MANY:
recv_sctp_rr_1toMany();
break;
#endif
default:
fprintf(where,"unknown test number %d\n",
netperf_request.content.request_type);
fflush(where);
netperf_response.content.serv_errno=998;
send_response();
break;
}
}
}
//--------------------------------------------------------------------------
bool rpc_debmod_t::open_remote(const char *hostname, int port_number, const char *password)
{
rpc_packet_t *rp = NULL;
irs = init_client_irs(hostname, port_number);
if (irs == NULL)
{
failed:
connection_failed(rp);
return false;
}
rp = recv_request(PRF_DONT_POLL);
if ( rp == NULL )
goto failed;
if ( rp->code != RPC_OPEN ) // is this an ida debugger server?
{
connection_failed(rp);
rpc_client_t::dwarning("ICON ERROR\nAUTOHIDE NONE\n"
"Bogus remote server");
return false;
}
const uchar *answer = (uchar *)(rp+1);
const uchar *end = answer + rp->length;
int version = extract_long(&answer, end);
int remote_debugger_id = extract_long(&answer, end);
int easize = extract_long(&answer, end);
qstring errstr;
if ( version != IDD_INTERFACE_VERSION )
errstr.sprnt("protocol version is %d, expected %d", version, IDD_INTERFACE_VERSION);
else if ( remote_debugger_id != debugger.id )
errstr.sprnt("debugger id is %d, expected %d (%s)", remote_debugger_id, debugger.id, debugger.name);
else if ( easize != (inf.is_64bit() ? 8 : 4) )
errstr.sprnt("address size is %d bytes, expected %d", easize, inf.is_64bit() ? 8 : 4);
if ( !errstr.empty() )
{
connection_failed(rp);
qstring cmd = prepare_rpc_packet(RPC_OK);
append_long(cmd, false);
send_request(cmd);
warning("ICON ERROR\nAUTOHIDE NONE\n"
"Incompatible debugging server:\n"
"%s\n", errstr.c_str());
return false;
}
qfree(rp);
qstring cmd = prepare_rpc_packet(RPC_OK);
append_long(cmd, true);
append_str(cmd, password);
send_request(cmd);
rp = recv_request(PRF_DONT_POLL);
if ( rp == NULL || rp->code != RPC_OK )
goto failed;
answer = (uchar *)(rp+1);
end = answer + rp->length;
bool password_ok = extract_long(&answer, end);
if ( !password_ok ) // is this an ida debugger server?
{
connection_failed(rp);
warning("ICON ERROR\nAUTOHIDE NONE\n"
"Bad password");
return false;
}
qfree(rp);
return true;
}
void
process_requests()
{
float temp_rate;
if (debug) {
fprintf(where,
"%s: enter\n",
__FUNCTION__);
fflush(where);
}
while (1) {
if (recv_request() == 0)
return;
switch (netperf_request.content.request_type) {
case DEBUG_ON:
netperf_response.content.response_type = DEBUG_OK;
if (!suppress_debug) {
debug++;
if (debug == 1) {
/* we just flipped-on debugging, dump the request because
recv_request/recv_request_n will not have dumped it as its
dump_request() call is conditional on debug being set. raj
2011-07-08 */
dump_request();
}
}
send_response();
break;
case DEBUG_OFF:
if (debug)
debug--;
netperf_response.content.response_type = DEBUG_OK;
send_response();
/* we used to take the trouble to close the debug file, but SAF
asked a good question when he asked "Why?" and since I cannot
think of a good reason, I have removed the code. raj
2011-07-08 */
break;
case DO_SYSINFO:
{
char *delims[4];
int i;
delims[0] = strdup("|");
delims[1] = strdup(",");
delims[2] = strdup("_");
delims[3] = strdup(";");
netperf_response.content.response_type = SYSINFO_RESPONSE;
for (i = 0; i < 4; i++) {
if ((!strstr(local_sysname,delims[i])) &&
(!strstr(local_release,delims[i])) &&
(!strstr(local_machine,delims[i])) &&
(!strstr(local_version,delims[i]))) {
snprintf((char *)netperf_response.content.test_specific_data,
sizeof(netperf_response.content.test_specific_data),
"%c%s%c%s%c%s%c%s",
delims[i][0],
local_sysname,
delims[i][0],
local_release,
delims[i][0],
local_machine,
delims[i][0],
local_version);
break;
}
}
if (i == 4) {
/* none of the delimiters were unique, use the last one of
course, the last one is not i but i-1 */
i -= 1;
snprintf((char *)netperf_response.content.test_specific_data,
sizeof(netperf_response.content.test_specific_data),
"%c%s%c%s%c%s%c%s",
delims[i][0],
"NoDelimUnique",
delims[i][0],
"NoDelimUnique",
delims[i][0],
"NoDelimUnique",
delims[i][0],
"NoDelimUnique");
}
send_response_n(0);
break;
}
case CPU_CALIBRATE:
netperf_response.content.response_type = CPU_CALIBRATE;
temp_rate = calibrate_local_cpu(0.0);
bcopy((char *)&temp_rate,
(char *)netperf_response.content.test_specific_data,
sizeof(temp_rate));
bcopy((char *)&lib_num_loc_cpus,
(char *)netperf_response.content.test_specific_data +
sizeof(temp_rate),
sizeof(lib_num_loc_cpus));
if (debug) {
fprintf(where,
"netserver: sending CPU information: rate is %g num cpu %d\n",
temp_rate,
lib_num_loc_cpus);
fflush(where);
}
/* we need the cpu_start, cpu_stop in the looper case to kill
the child proceses raj 7/95 */
#ifdef USE_LOOPER
cpu_start(1);
cpu_stop(1,&temp_rate);
#endif /* USE_LOOPER */
send_response();
break;
case DO_TCP_STREAM:
recv_tcp_stream();
break;
case DO_TCP_MAERTS:
recv_tcp_maerts();
break;
case DO_TCP_RR:
recv_tcp_rr();
break;
case DO_TCP_CRR:
recv_tcp_conn_rr();
break;
case DO_TCP_CC:
recv_tcp_cc();
break;
#ifdef DO_1644
case DO_TCP_TRR:
recv_tcp_tran_rr();
break;
#endif /* DO_1644 */
#ifdef DO_NBRR
case DO_TCP_NBRR:
recv_tcp_nbrr();
break;
#endif /* DO_NBRR */
case DO_UDP_STREAM:
recv_udp_stream();
break;
case DO_UDP_RR:
recv_udp_rr();
break;
#ifdef WANT_DLPI
case DO_DLPI_CO_RR:
recv_dlpi_co_rr();
break;
case DO_DLPI_CL_RR:
recv_dlpi_cl_rr();
break;
case DO_DLPI_CO_STREAM:
recv_dlpi_co_stream();
break;
case DO_DLPI_CL_STREAM:
recv_dlpi_cl_stream();
break;
#endif /* WANT_DLPI */
#ifdef WANT_UNIX
case DO_STREAM_STREAM:
recv_stream_stream();
break;
case DO_STREAM_RR:
recv_stream_rr();
break;
case DO_DG_STREAM:
recv_dg_stream();
break;
case DO_DG_RR:
recv_dg_rr();
break;
#endif /* WANT_UNIX */
#ifdef WANT_XTI
case DO_XTI_TCP_STREAM:
recv_xti_tcp_stream();
break;
case DO_XTI_TCP_RR:
recv_xti_tcp_rr();
break;
case DO_XTI_UDP_STREAM:
recv_xti_udp_stream();
break;
case DO_XTI_UDP_RR:
recv_xti_udp_rr();
break;
#endif /* WANT_XTI */
#ifdef WANT_SCTP
case DO_SCTP_STREAM:
recv_sctp_stream();
break;
case DO_SCTP_STREAM_MANY:
recv_sctp_stream_1toMany();
break;
case DO_SCTP_RR:
recv_sctp_rr();
break;
case DO_SCTP_RR_MANY:
recv_sctp_rr_1toMany();
break;
#endif
#ifdef WANT_SDP
case DO_SDP_STREAM:
recv_sdp_stream();
break;
case DO_SDP_MAERTS:
recv_sdp_maerts();
break;
case DO_SDP_RR:
recv_sdp_rr();
break;
#endif
#ifdef WANT_OMNI
case DO_OMNI:
recv_omni();
break;
#endif
default:
fprintf(where,"unknown test number %d\n",
netperf_request.content.request_type);
fflush(where);
netperf_response.content.serv_errno=998;
send_response();
break;
}
}
}
