int req1(PCStr(host),int port){
int sock;
FILE *ts,*fs;
int ch;
fprintf(stderr,"------------ %s %d\n",host,port);
sock = client_open("TSP","TSP",host,port);
if( sock < 0 )
return -1;
ts = fdopen(sock,"w");
fs = fdopen(sock,"r");
putc(0,ts); putc(0,ts); putc(0,ts); putc(0,ts);
putc(0,ts);
fflush(ts);
for(;;){
ch = getc(fs);
if( ch == EOF ){
break;
}
if( 0x20 <= ch && ch < 0x7F )
fprintf(stderr,"%c",ch);
else fprintf(stderr,"[%X]",ch);
}
fprintf(stderr,"\n");
fclose(ts);
fclose(fs);
return 0;
}
void MainWindow::on_test_90_2_clicked()
{
struct fileinfo finfo = {
finfo.copysize=1,
finfo.filetype=NORMAL_FILE,
finfo.blocklength=BLOCKLENGTH,
};
memcpy(finfo.name,"test_90_2",100);
long long testfid = client_create(&finfo);
int testfd = client_open(testfid,O_READ);
client_close(testfd);
// char buff[BUFFSIZE];
int buffSize = atoi(ui->lineEdit_buffSize->text().toAscii());
char* buff = new char [buffSize*1024*1024];
int result = client_read(testfd,buff,(buffSize*1024*1024)*sizeof(char));
qDebug()<<result;
if(result == -1 and testfd != -1){
char name1[100];
int errcode = getlasterror(testfd,name1,100);
qDebug()<<"ERROR:"<<errcode<<name1;
if(errcode == 102){
ui->textEdit->append(QString::number(lineCount) + " -----> read to the closed file test OK");
lineCount++;
}
else{
ui->textEdit->append(QString::number(lineCount) + " -----> read to the closed file test FAIL");
lineCount++;
}
}
delete [] buff;
}
int open_lpr(PCStr(host),int port,FILE **tsp,FILE **fsp)
{ const char *lpr_host;
int lpr_port;
int sock;
if( host && *host )
lpr_host = host;
else
if( (lpr_host = getenv("PRINTER")) && *lpr_host )
syslog_DEBUG("PRINTER=%s\n",lpr_host);
else lpr_host = "localhost";
if( 0 < port )
lpr_port = port;
else lpr_port = 515;
/* should try binding source port in range [721-731] */
sock = client_open("LPR","lpr",lpr_host,lpr_port);
if( sock < 0 ){
syslog_ERROR("can't open %s:%d\n",lpr_host,lpr_port);
return -1;
}
*tsp = fdopen(sock,"w");
*fsp = fdopen(sock,"r");
return 0;
}
/*
* Called when controller got OP_OPEN
* The controller passes the request to a chosen server
*/
void controller_open(int *backend_socket, int client_socket,
struct op_hdr get_hdr) {
int len = -1;
int fd = -1; // FD
int mode = -1;
int name_len = 0;
struct op_hdr put_hdr;
int s_idx = -1;
char path_buff[4096];
// init
put_hdr = get_hdr;
mode = get_hdr.p1;
name_len = get_hdr.p2; // Size of file name
printf("\tname_len: %d, mode: %d\n", name_len, mode);
/* Read the actual data (name of the file) */
READ_ALL(len, client_socket, path_buff, name_len);
path_buff[name_len] = '\0';
printf("\tfilename: %s\n", path_buff);
// Open connection to the appropriate server
if ((s_idx = select_backend(path_buff)) < 0) {
printf("Requested file: %s not found\n", path_buff);
put_hdr.op = ERR_OPEN;
put_hdr.p1 = 0;
WRITE_SOC(len, client_socket, &put_hdr, HDR_SIZE);
return;
}
/* Connect to server */
if ((*backend_socket = connect_to_server(server_list[s_idx].name,
server_port)) < 0) {
perror("Connection to server failed");
put_hdr.op = ERR_OPEN;
put_hdr.p1 = errno;
WRITE_SOC(len, client_socket, &put_hdr, HDR_SIZE);
return;
}
/* Open the requested file on the backend server */
fd = client_open(*backend_socket, path_buff, mode);
/* Reply with the result */
put_hdr.op = OP_OPEN;
put_hdr.p1 = fd;
WRITE_SOC(len, client_socket, &put_hdr, HDR_SIZE);
}
static int Xnew(XFlash *Xf,int svsock){
Connection *Conn = Xf->xf_Conn;
int client;
int server;
for(;;){
client = ACCEPT(svsock,0,-1,0);
server = client_open("XFlash","XCFlash","127.0.0.1",6001);
if( server < 0 ){
continue;
}
FromC = ToC = client;
FromS = ToS = server;
Xf->xf_cstid = thread_fork(0,0,"XFlash-CS",(IFUNCP)XCS,Xf);
Xf->xf_sctid = thread_fork(0,0,"XFlash-SC",(IFUNCP)XSC,Xf,1024);
}
return 0;
}
bool MainWindow::uploadFile(long long fileFid,QString fileName)
{
bool res = false;
long long allrst = 0;
int fileFd = client_open(fileFid,O_WRITE);
qDebug()<<"fileName= "<<fileName<<" fileFid="<<fileFid<<" fileFd="<<fileFd;
QFile file(fileName);
qDebug()<<"file.size"<<file.size();
if(file.open(QIODevice::ReadOnly) and fileFid > 0 and fileFd > 0 and file.size() > 0){
// char buff[BUFFSIZE];
int buffSize = atoi(ui->lineEdit_buffSize->text().toAscii());
char* buff = new char [buffSize*1024*1024];
while(!file.atEnd()){
int size = file.read(buff,(buffSize*1024*1024)*sizeof(char));
qDebug()<<"read file size = "<<size ;
qDebug()<<"write start";
int result = client_write(fileFd,buff,size);
qDebug()<<"result"<<result;
if(result == -1){
char name[100];
qDebug()<<"ERROR:"<<getlasterror(fileFd,name,100)<<name;
break;
}
else{
allrst += result;
}
qDebug()<<allrst<<"/"<<file.size();
if(file.atEnd() and result != -1){
res = true;
}
}
delete [] buff;
}
else{
qDebug()<<fileName<<" open failed!!! or Fid|Fd < 0 or file.size = 0";
}
file.close();
client_close(fileFd);
return res;
}
void MainWindow::on_test_87_1_clicked()
{
struct fileinfo finfo = {
finfo.copysize=1,
finfo.filetype=NORMAL_FILE,
finfo.blocklength=BLOCKLENGTH,
};
memcpy(finfo.name,"test_87_1",100);
long long testfid = client_create(&finfo);
int testfd = client_open(testfid + 123,O_READ);
qDebug()<<testfid<<testfd;
if(testfd == -1 and testfid != -1){
ui->textEdit->append(QString::number(lineCount) + " -----> use wrong fileid to open file test OK");
lineCount++;
}
else{
ui->textEdit->append(QString::number(lineCount) + " -----> use wrong fileid to open file test FAIL");
lineCount++;
}
// client_uninit();
}
/*
* Replicates a given file
* Takes the index in the server table for from and to
* Caller must lock the global tables (modifies the file_list)
*/
int replicate(int f_idx, int from, int to)
{
char *f_name = file_list[f_idx].name;
char *s_from = server_list[from].name;
char *s_to = server_list[to].name;
int fd_from = -1;
int fd_to = -1;
int sock_from = -1;
int sock_to = -1;
int r_len = -1, w_len = -1;
char buff[8192];
// See if src is same as destn
if (from == to) {
printf ("***NO REPLICATE*** from == to\n");
return(-1);;
}
// connect to servers
if (((sock_from = connect_to_server(s_from, server_port)) < 0 ) ||
((sock_to = connect_to_server(s_to, server_port)) < 0 )) {
perror("Replication failed");
if (sock_from >= 0) close(sock_from);
if (sock_to >= 0) close(sock_to);
return(-1);
}
// open files
if (((fd_from = client_open(sock_from, f_name, O_RDONLY)) < 0 ) ||
((fd_to = client_open(sock_to, f_name, O_CREAT | O_WRONLY)) < 0 )) {
perror("Replication failed");
if (fd_from >= 0) client_close(sock_from, fd_from);
client_end(sock_from);
if(fd_to >= 0) client_close(sock_to, fd_to);
client_end(sock_to);
return(-2);
}
// read file from source server and transfer to dest server
do {
if ((r_len = client_read(sock_from, fd_from, buff,
sizeof(buff))) < 0) {
perror("Replication failed");
client_close(sock_from, fd_from);
client_end(sock_from);
client_close(sock_to, fd_to);
client_end(sock_to);
return(-3);
}
if ((w_len = client_write(sock_to, fd_to, buff,
r_len)) < 0 ) {
perror("Replication failed");
client_close(sock_from, fd_from);
client_end(sock_from);
client_close(sock_to, fd_to);
client_end(sock_to);
return(-4);
}
} while (r_len == sizeof(buff)); // read until eof
// close files
client_close(sock_from, fd_from);
client_end(sock_from);
client_close(sock_to, fd_to);
client_end(sock_to);
// update tables - add destn server to file's record
file_list[f_idx].index[file_list[f_idx].tot_idx++] = to;
return(0);
}
int main( int argc, char *argv[] )
{
GtkWidget *vbox;
gtk_init( &argc, &argv );
if( client_open( NULL ) )
exit( 1 );
atexit( client_close );
window = argc == 2 ?
gtk_plug_new( strtol( argv[1], NULL, 10 )) :
gtk_window_new( GTK_WINDOW_TOPLEVEL );
vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
drawing_area = gtk_drawing_area_new();
/* Get the dimensions and colors of the pager and viewport and focus */
parse_stdin();
update_rect.x = update_rect.y = 0;
gtk_drawing_area_size( GTK_DRAWING_AREA( drawing_area ), width, height );
gtk_box_pack_start( GTK_BOX( vbox ), drawing_area, FALSE, FALSE, 0 );
/* Signals to quit */
g_signal_connect( GTK_OBJECT( window ), "delete_event",
G_CALLBACK( delete_event ), NULL );
g_signal_connect( GTK_OBJECT( window ), "destroy",
G_CALLBACK( destroy_event ), NULL );
/* Wait for input from standard input */
gdk_input_add( 0, GDK_INPUT_READ,
&wait_stdin,
drawing_area );
/* Change the viewport when a button is pressed */
g_signal_connect( GTK_OBJECT( drawing_area ), "motion_notify_event",
(GCallback) motion_notify_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "button_press_event",
(GCallback) button_press_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "button_release_event",
(GCallback) button_release_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "leave_notify_event",
(GCallback) leave_notify_event, NULL );
g_signal_connect ( GTK_OBJECT( drawing_area), "scroll_event",
(GCallback) scroll_event, NULL );
gtk_widget_set_events( drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_SCROLL_MASK );
/* Initialize and draw the pixmap */
g_signal_connect( GTK_OBJECT( drawing_area ), "expose_event",
(GCallback) expose_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "configure_event",
(GCallback) configure_event, NULL );
gtk_widget_show( drawing_area );
gtk_widget_show( vbox );
wmspec_change_state(TRUE, window->window,
gdk_atom_intern( "_NET_WM_STATE_SKIP_PAGER", FALSE ),
gdk_atom_intern( "_NET_WM_STATE_SKIP_TASKBAR", FALSE ));
gtk_window_set_type_hint( GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_show( window );
gtk_main();
return 0;
}
void client(client_t* client_dat,int client_sock_fd){
// The account of the active client
account_t* client_account = NULL;
// Set up parameters for select
struct timeval timeout ={ TIME_OUT, 0 }; // Timeout after 5000 seconds
fd_set read_fd_set;
FD_ZERO(&read_fd_set);
FD_SET(client_sock_fd, &read_fd_set);
int active_sockets;
request_t request;
response_t response;
while((active_sockets = select(client_sock_fd+1,&read_fd_set,NULL,NULL,
&timeout))>0){
int byte_read = listen_request(&request,client_sock_fd);
if(byte_read == 0){
// Client closed connection unexpectedly. (not manually)
if(client_account != NULL){
set_not_in_session(client_account);
client_account = NULL;
}
break;
}
if(client_account == NULL || !account_is_in_session(client_account)){
// Current client did not open the
switch(request.code){
case OPEN:
client_open(&response,client_dat,request.message.name);
break;
case START:
client_start(&response,client_dat,&client_account
,request.message.name,client_sock_fd);
break;
case EXIT:
form_response(&response,ACCOUNT_EXIT,"Exit acknowledged.");
break;
default:
form_response(&response,CLIENT_NOT_IN_SESSION,"Please "\
"start an account before doing the transaction.");
break;
}
}else{
switch(request.code){
case OPEN:
form_response(&response,CANNOT_OPEN,"Please finish this"\
" account session first.");
break;
case START:
form_response(&response,CANNOT_START,"Please finish this"\
" account session first.");
break;
case DEBIT:
client_debit(&response,client_account,request.message.amount);
break;
case CREDIT:
client_credit(&response,client_account,request.message.amount);
break;
case BALANCE:
form_response(&response,SUCCESS,"");
sprintf(response.message,"Account: %s.\nYour balance is %.2f.",
client_account->name,client_account->balance);
break;
case FINISH:
set_not_in_session(client_account);
form_response(&response,SUCCESS,"Account session closed.");
client_account = NULL;
break;
case EXIT:
set_not_in_session(client_account);
form_response(&response,ACCOUNT_EXIT,"Exit acknowledged and "\
"account session closed.");
client_account = NULL;
break;
default:
form_response(&response,SUCCESS,"Not a valid request.");
break;
}
}
// Send the response to the client without failing!
while(write(client_sock_fd,&response,sizeof(response_t))<0){
continue;
}
if(request.code == EXIT){
break;
}
}
if(active_sockets == 0 ){
if (client_account!=NULL){
set_not_in_session(client_account);
client_account = NULL;
}
form_response(&response, CONNECTION_TIME_OUT,"Connection time out.");
write(client_sock_fd, &response,sizeof(response_t));
}
exit(EXIT_SUCCESS);
}
