int
CodeRevision::removetcp(int i) {
fprintf(stderr, "removing shred %d\n", _shreds[i]->procID );
connect_tcp();
if ( _connected ) {
Net_Msg msg;
msg.type = MSG_REMOVE;
// msg.param = _shreds[i].procID;
msg.param = 0xffffffff;
otf_hton( &msg);
ck_send( _tcp , (char*)&msg, sizeof(msg) );
msg.type = MSG_DONE;
otf_hton( &msg);
ck_send( _tcp , (char*)&msg, sizeof(msg) );
// Net_Msg ret;
// if ( ck_recv( _tcp , (char *)&ret, sizeof(ret) ) ) {
// fprintf( stderr, "[chuck(remote)]: operation %s\n", ( ret.param ? "successful" : "failed (sorry)" ) );
_shreds.erase( _shreds.begin() + i );
// }
}
close_tcp();
return 1;
}
/* Stop TCP discard server */
int
dis0(
int argc,
char *argv[],
void *p)
{
if(disc_tcb != NULL)
close_tcp(disc_tcb);
return 0;
}
/* Stop TCP echo server */
int
echo0(
int argc,
char *argv[],
void *p)
{
if(echo_tcb != NULL)
close_tcp(echo_tcb);
return 0;
}
int
so_tcp_close(struct usock *up)
{
if(up->cb.tcb != NULL){ /* In case it's been reset */
up->cb.tcb->r_upcall = trdiscard;
/* Tell the TCP_CLOSED upcall there's no more socket */
up->cb.tcb->user = -1;
close_tcp(up->cb.tcb);
}
return 0;
}
/* Start up FTP service */
int
ftpstart(int argc,char *argv[],void *p)
{
struct socket lsocket;
if(ftp_tcb != NULL)
close_tcp(ftp_tcb);
lsocket.address = INADDR_ANY;
if(argc < 2)
lsocket.port = IPPORT_FTP;
else
lsocket.port = tcp_port_number(argv[1]);
ftp_tcb = open_tcp(&lsocket,NULL,TCP_SERVER,0,ftpscr,NULL,ftpscs,0,0);
return 0;
}
static void tcp_receive(struct tcb *tcb, int32 cnt)
{
char buffer[1024];
struct mbuf *bp;
if (tcb->user > 0) {
recv_tcp(tcb, &bp, 0);
while ((cnt = pullup(&bp, buffer, sizeof(buffer))) > 0)
if (write(tcb->user, buffer, (unsigned) cnt) != cnt) {
free_p(&bp);
close_tcp(tcb);
return;
}
}
}
void
TextContent::sendtcp () {
string blob = "";
for ( int i = 0 ; i < _buf->nlines() ; i++ ) {
blob += _buf->line(i).str();
if ( i != _buf->nlines() - 1 ) blob += "\n";
}
connect_tcp();
if ( _connected ) {
//DO THAT TCP MAGIC THING
Net_Msg msg;
msg.type = MSG_ADD;
msg.param = 1;
strcpy ( (char*)msg.buffer, "editor->" );
strcat ( (char*)msg.buffer, _buf->filename().c_str() );
msg.param2 = (t_CKUINT) blob.size(); //trailing NUL?
msg.length = 0;
otf_hton( &msg );
ck_send ( _tcp , (char *)&msg, sizeof(msg) );
t_CKUINT left = blob.size() ; //include trailing NUL ?
t_CKUINT done = 0;
while ( left ) {
msg.length = ( left > NET_BUFFER_SIZE ) ? NET_BUFFER_SIZE : left;
msg.param3 = msg.length;
memcpy( (void*)msg.buffer, (void*) (blob.c_str() + done ), msg.length * sizeof (char) );
left -= msg.length;
done += msg.length;
msg.param2 = left;
fprintf(stderr, "sending %ld to %ld of %s\n", done - msg.length, done, _buf->filename().c_str());
otf_hton( &msg );
ck_send ( _tcp, (char*)&msg, sizeof(msg) );
}
msg.type = MSG_DONE;
otf_hton( &msg );
ck_send (_tcp , (char*)&msg, sizeof(msg));
close_tcp();
}
else {
fprintf(stderr,"sendtcp::unable to establish connection to ChucK process...\n");
}
}
int
so_tcp_shut(struct usock *up,int how)
{
switch(how){
case 0: /* No more receives -- replace upcall */
up->cb.tcb->r_upcall = trdiscard;
break;
case 1: /* Send EOF */
close_tcp(up->cb.tcb);
break;
case 2: /* Blow away TCB */
reset_tcp(up->cb.tcb);
up->cb.tcb = NULL;
break;
}
return 0;
}
static void tcp_send(struct tcb *tcb)
{
int cnt;
struct mbuf *bp;
if ((cnt = space_tcp(tcb)) <= 0) {
off_read(tcb->user);
return;
}
if (!(bp = alloc_mbuf(cnt))) return;
cnt = read(tcb->user, bp->data, (unsigned) cnt);
if (cnt <= 0) {
free_p(&bp);
off_read(tcb->user);
close_tcp(tcb);
return;
}
bp->cnt = cnt;
send_tcp(tcb, &bp);
}
int emc_control(int plug, int id, int ctl){
int result = -1;
struct easymc_plug * pg = (struct easymc_plug *)global_get_plug(plug);
if(!pg){
errno = ENOPLUG;
return -1;
}
if(!get_device_control(pg->device)) return -1;
if(ctl & EMC_CTL_CLOSE){
if(pg->ipc_){
if(0 == close_ipc(pg->ipc_, id)){
result = 0;
}
}
if(pg->tcp_){
if(0 == close_tcp(pg->tcp_, id)){
result = 0;
}
}
}
return result;
}
int main (int argc, char *argv[])
{
args_t args;
memset (&args, 0, sizeof(args));
// set default parameters
args.address = NULL;
args.ai_family = AF_INET;
args.port = DEFAULT_PORT;
args.port_nbr = atoi(args.port);
args.mode = -1;
printf ("\n[ simple remote shell for windows v2\n");
parse_args(&args, argc, argv);
if (args.mode == -1) {
if (args.address==NULL) {
args.mode=SERVER_MODE;
} else {
args.mode=CLIENT_MODE;
}
}
if (open_tcp(&args))
{
if (args.mode == SERVER_MODE)
{
server(&args);
} else {
client(&args);
}
close_tcp(&args);
}
return 0;
}
int main (int argc, char *argv[])
{
INIT_SECURITY_INTERFACE pInitSecurityInterface;
// set buffer width of console
setw (300);
puts ("\n [ cms v0.1 - Copyleft 2015 (x) @Odzhan\n");
// set up default values
args.address = NULL;
args.ai_family = AF_INET;
args.port = DEFAULT_PORT;
args.port_nbr = atoi(args.port);
pInitSecurityInterface = (INIT_SECURITY_INTERFACE)GetProcAddress(LoadLibrary("Secur32"), "InitSecurityInterfaceA" );
if (pInitSecurityInterface==NULL) printf ("didn't resolve");
sspi = pInitSecurityInterface();
// process command line
parse_args(argc, argv);
// resolve address and open socket
if (open_tcp ())
{
start_handler ();
// create credentials
if (create_creds()==SEC_E_OK)
{
// connect to server
if (connect (s, ai_addr, ai_addrlen) != SOCKET_ERROR) {
// perform the handshake
if (chs () == SEC_E_OK) {
printf (" [ connected\n\n");
secure_info();
ss=sspi->QueryContextAttributes (&hContext, SECPKG_ATTR_STREAM_SIZES, &Sizes );
cbBufferLen = Sizes.cbHeader + Sizes.cbMaximumMessage + Sizes.cbTrailer;
pbBufferIn = LocalAlloc(LMEM_FIXED, cbBufferLen);
pbBufferOut = LocalAlloc(LMEM_FIXED, cbBufferLen);
pbDataIn=pbBufferIn + Sizes.cbHeader;
pbDataOut=pbBufferOut + Sizes.cbHeader;
cbBufferLen = Sizes.cbMaximumMessage;
printf (" [ running cmd\n");
cmd();
} else {
printf (" [ handshake failed\n");
}
} else {
printf (" [ unable to connect\n");
}
} else {
printf (" [ error creating credentials\n");
}
stop_handler ();
close_tcp();
}
return 0;
}
int
CodeRevision::sendtcp( int replace ) {
string blob = "";
for ( int i = 0 ; i < _buffer->nlines() ; i++ ) {
blob += _buffer->line(i).str();
if ( i != _buffer->nlines() - 1 ) blob += "\n";
}
connect_tcp();
if ( _connected ) {
//DO THAT TCP MAGIC THING
Net_Msg msg;
if ( replace == 0 ) {
msg.type = MSG_ADD;
msg.param = 1;
}
else {
msg.type = MSG_REPLACE;
msg.param = replace;;
}
strcpy ( (char*)msg.buffer, "editor->" );
strcat ( (char*)msg.buffer, _buffer->filename().c_str() );
msg.param2 = (t_CKUINT) blob.size(); //trailing NUL?
msg.length = 0;
otf_hton( &msg );
ck_send ( _tcp , (char *)&msg, sizeof(msg) );
t_CKUINT left = blob.size() ; //include trailing NUL ?
t_CKUINT done = 0;
while ( left ) {
msg.length = ( left > NET_BUFFER_SIZE ) ? NET_BUFFER_SIZE : left;
msg.param3 = msg.length;
memcpy( (void*)msg.buffer, (void*) (blob.c_str() + done ), msg.length * sizeof (char) );
left -= msg.length;
done += msg.length;
msg.param2 = left;
fprintf(stderr, "sending %ld to %ld of %s\n", done - msg.length, done, _buffer->filename().c_str());
otf_hton( &msg );
ck_send ( _tcp, (char*)&msg, sizeof(msg) );
}
msg.type = MSG_DONE;
otf_hton( &msg );
ck_send (_tcp , (char*)&msg, sizeof(msg));
Net_Msg ret;
if ( ck_recv( _tcp , (char *)&ret, sizeof(ret) ) ) {
fprintf( stderr, "[chuck(remote)]: operation %s\n", ( ret.param ? "successful" : "failed (sorry)" ) );
}
close_tcp();
return ( ret.param ) ? 1 : 0 ;
}
else {
fprintf(stderr,"sendtcp::unable to establish connection to ChucK process...\n");
}
return 0;
}
void http_disconnect(http_client_t *http_client)
{
http_request_destroy(&http_client->request);
http_response_destroy(&http_client->response);
close_tcp(&http_client->connection);
}
int main(int argc, char * argv[])
#endif
{
bool threaded = false;
ETERM *cmd_tuple;
#ifdef __WIN32__
_setmode( _fileno( stdout ), _O_BINARY );
_setmode( _fileno( stdin ), _O_BINARY );
#endif
erl_init(NULL, 0);
log_flag = false;
if (argc >= 2) {
if (
#ifdef __WIN32__
wcscmp(argv[1], L"true") == 0
#else
strcmp(argv[1], "true") == 0
#endif
) log_flag = true;
}
if (argc >= 3) {
int ListenPortNo =
#ifdef __WIN32__
_wtoi(argv[2]);
#else
atoi(argv[2]);
#endif
char * ret = connect_tcp(ListenPortNo);
if(ret != NULL) {
return -1;
} else
REMOTE_LOG("Logging over TCP, Voila!\n");
}
init_marshall();
REMOTE_LOG("Port: OCI Process started...\n");
threaded = InitializeThreadPool();
if(threaded)
REMOTE_LOG("Port: Thread pool created...\n");
REMOTE_LOG("Port: Initialized Oracle OCI\n");
while(!exit_loop && (cmd_tuple = (ETERM *)read_cmd()) != NULL) {
if(threaded && ProcessCommand(cmd_tuple)) {
//REMOTE_LOG("Port: Command sumitted to thread-pool for processing...");
}
}
REMOTE_LOG("Port: Process oci terminating...\n");
close_tcp();
REMOTE_LOG("Port: Thread pool destroyed...\n");
CleanupThreadPool();
return 0;
}
/* Implements the general case for command message send-receive
*
* If any of our underlying calls return an error, we will pass
* that up to our caller immediately.
*
* Otherwise we'll examine the response.
*
* Returns:
* - some errno from one of our calls
* - INVALID_ID if the server does not recognize our member id
* - COMMAND_SUCC on success
* - COMMAND_FAIL on failure
* - BOGUS_RESPONSE on an unexpected reply
*
* Takes advantage of the fact that for a request message type
* x, the corresponding success and fail responses are x+1
* and x+2 respectively. We encode that relationship in the macros
* CODE_SUCC() and CODE_FAIL(). Keepalive and quit messages do not
* wait for a response.
*/
int generic_command(int msg_type, char *arg, char *buf) {
int ret = 0, bytes = 0;
struct control_msghdr *cmh = (struct control_msghdr *) buf;
memset(buf, 0, MAX_MSG_LEN);
cmh->msg_type = msg_type;
cmh->member_id = /*htons*/(member_id);
cmh->msg_len = /*htons*/(sizeof(struct control_msghdr));
if (arg) {
strcpy((char *)(cmh->msgdata), arg);
cmh->msg_len += strlen(arg);
}
if (msg_type == REGISTER_REQUEST) {
struct register_msgdata *rdata;
rdata = (struct register_msgdata *)cmh->msgdata;
/* send registration data */
rdata->udp_port = htons(client_udp_port);
strcpy((char *)rdata->member_name, member_name);
cmh->msg_len +=
sizeof(struct register_msgdata) + strlen(member_name);
}
/* OPEN */
if ((ret = open_tcp()) != 0) {
return ret;
}
/* WRITE */
if ((bytes = write(tcp_sock, buf, /*ntohs*/(cmh->msg_len))) == -1) {
ret = errno;
fprintf(stderr, "%s: write: %s\n", __func__, strerror(errno));
return ret;
} else {
seen_server();
}
debug_sub_print(DBG_TCP, "%s: %dB written\n", __func__, bytes);
/* Response expected? */
if (msg_type < MEMBER_KEEP_ALIVE) {
if ((bytes = recv(tcp_sock, buf, MAX_MSG_LEN, 0)) == -1) {
ret = errno;
fprintf(stderr, "%s: recv'd: %s\n", __func__, strerror(errno));
return ret;
}
close_tcp();
debug_sub_print(DBG_TCP, "%s: %dB recv'd\n", __func__, bytes);
if ((cmh->msg_type) == CODE_SUCC(msg_type)) {
return COMMAND_SUCC;
} else if ((cmh->msg_type) == CODE_FAIL(msg_type)) {
if ((strstr((char *) (cmh->msgdata), "Member id invalid!"))
== (char *) (cmh->msgdata))
{
return ID_INVALID;
}
return COMMAND_FAIL;
} else {
fprintf(stderr, "Unexpected response (%d)\n", cmh->msg_type);
return BOGUS_RESPONSE;
}
} else {
close_tcp();
}
return ret;
}
