int main(int argc, char *argv[])
{
int sockfd;
struct sockaddr_in servaddr;
if (argc != 2)
handle_err("usage: client <IP address>");
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1)
handle_err("socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
if (inet_aton(argv[1], &servaddr.sin_addr) == 0)
handle_err("error IP address");
// if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) {
// handle_err("connecting error");
// }
// printf("Finish connecting\n");
str_cli(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
close(sockfd);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int sockfd, count;
struct sockaddr_in servaddr;
struct sigaction act, oact;
// act.sa_handler = sig_pipe;
act.sa_handler = SIG_IGN;
if (argc != 2)
handle_err("usage: client <IP address>");
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
handle_err("socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(argv[1]);
servaddr.sin_port = htons(SERV_PORT);
if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
handle_err("connecting error");
if (shutdown(sockfd, SHUT_RD) < 0)
handle_err("shutdown error");
if (sigaction(SIGPIPE, &act, &oact) < 0) {
handle_err("sigaction error");
}
cli_str(sockfd);
close(sockfd);
exit(EXIT_SUCCESS);
}
int open_listenfd() {
int listenfd, ret;
int optval = 1;
struct sockaddr_in servaddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
handle_err(listenfd == -1, "server listenfd");
ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval, sizeof(optval));
handle_err(ret == -1, "setsockopt in eliminating address already used\n");
ret = setsockopt(listenfd, 6, TCP_CORK, (const void *)&optval, sizeof(optval));
handle_err(ret == -1, "setsockopt in enhancing response speed");
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERVER_PORT);
servaddr.sin_addr.s_addr = inet_addr(SERVER_IP);
ret = bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
handle_err(ret < 0, "server bind");
ret = listen(listenfd, SOMAXCONN);
handle_err(ret < 0, "server listen");
return listenfd;
}
int main(int argc, char *argv[])
{
signal(SIGUSR1, handle_signal);
global_init();
int listenfd = open_listenfd();
struct epoll_event event;
struct sockaddr_in peeraddr;
socklen_t socklen;
int sock;
int nready, i;
char buf[1024];
epollfd = epoll_create1(EPOLL_CLOEXEC);
event.data.fd = listenfd;
event.events = EPOLLIN | EPOLLET;
epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);
while (g_switch == 0) {
nready = epoll_wait(epollfd, events, MAX_EVENTS, -1);
if (nready == -1) {
if (errno == EINTR)
continue;
handle_err(1, "epoll_wait");
}
for (i = 0; i < nready; ++i) {
if (events[i].data.fd == listenfd) {
socklen = sizeof(peeraddr);
sock = accept4(listenfd, (struct sockaddr *) &peeraddr, &socklen, SOCK_NONBLOCK);
handle_err(sock == -1, "accept4");
printf("new client %s:%hu accepted\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
sprintf(buf, "recv from (%s:%hu)\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
write_log(buf);
event.data.fd = sock;
event.events = EPOLLIN | EPOLLET;
epoll_ctl(epollfd, EPOLL_CTL_ADD, sock, &event);
} else {
int *ptr = malloc(sizeof(int));
*ptr = events[i].data.fd;
threadpool_add(thp, do_task, (void *)(ptr), 0);
}
}
}
global_destroy();
return 0;
}
int main(){
struct sockaddr_in serveraddr;
struct sockaddr_in clientaddr;
int addrlen;
int listenfd;
listenfd = Socket(AF_INET,SOCK_STREAM,0);
bzero(&serveraddr,sizeof(struct sockaddr_in));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(PORT);
int optval = 1;
if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(optval))==-1){
close(listenfd);
handle_err("setsockopt error\n");
}
Bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(struct sockaddr_in));
Listen(listenfd,128);
//忽略可以避免僵尸进程
//signal(SIGCHLD,SIG_IGN);
signal(SIGCHLD,handle_sig);
while(1){
addrlen = sizeof(struct sockaddr_in);
int connfd = Accept(listenfd,(struct sockaddr *)&clientaddr,&addrlen);
pid_t pid = fork();
if(pid==0){
close(listenfd);
char buf[1024] = {0};
while(1){
int ret = Read(connfd,buf,sizeof(buf));
if(ret<=0){
break;
}
fputs(buf,stdout);
memset(buf,0,sizeof(buf));
}
close(connfd);
handle_err("read error\n");
}else if(pid<0){
break;
}
}
handle_err("fork error\n");
close(listenfd);
return 0;
}
int main(){
struct sockaddr_in clientaddr;
int sockfd;
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd==-1){
handle_err("socket error\n");
}
bzero(&clientaddr,sizeof(struct sockaddr_in));
clientaddr.sin_family = AF_INET;
clientaddr.sin_addr.s_addr = inet_addr(SERVERIP);
clientaddr.sin_port = htons(PORT);
if((connect(sockfd,(struct sockaddr *)&clientaddr,sizeof(struct sockaddr_in)))==-1){
close(sockfd);
handle_err("connect error");
}
pid_t pid = fork();
//父进程发送数据
if(pid>0){
char send_buf[1024] = {0};
while(fgets(send_buf,sizeof(send_buf),stdin)!=NULL){
write(sockfd,send_buf,strlen(send_buf));
memset(send_buf,0,sizeof(send_buf));
}
}else if(pid==0){
char recv_buf[1024] = {0};
while(1){
int len = read(sockfd,recv_buf,sizeof(recv_buf));
if(len==-1){
handle_err("read error\n");
}else if(len==0){
printf("server close\n");
break;
}else{
fputs(recv_buf,stdout);
memset(recv_buf,0,sizeof(recv_buf));
}
}
close(sockfd);
kill(getppid(),SIGUSR1);
}else{
close(sockfd);
handle_err("fork error\n");
}
close(sockfd);
}
void read_data(int sockfd, int count)
{
ssize_t n;
char buf[count];
struct timeval start;
struct timeval end;
float sec, usec, diff;
int flag = 0;
for ( ; ; ) {
while ((n = read(sockfd, buf, count)) > 0) {
if (n > 0 && flag == 0) {
// gettimeofday from <sys/time.h>
gettimeofday(&start, NULL);
flag = 1;
}
}
if (n == 0 && flag == 1) {
gettimeofday(&end, NULL);
sec = end.tv_sec - start.tv_sec;
usec = end.tv_usec - start.tv_usec;
diff = sec + usec / 1000000;
printf("The elapsed time for receiving is %fs\n", diff);
flag = 0;
}
if (n < 0)
handle_err("read error");
}
}
void read_config(void) {
FILE *fp = fopen(CONFIG_PATH, "r");
handle_err(fp == NULL, "can't open config file.");
char buf[1024];
int n;
while (fgets(buf, sizeof(buf), fp)) {
n = 0;
while (isspace(buf[n])) ++n;
if (buf[n] == '\0')
continue;
char *p = strchr(buf, '=');
*p = '\0';
char *key = buf;
char *value = p + 1;
if (!strcmp("SERVER_IP", key)) {
sscanf(value, "%s", SERVER_IP);
printf("IP:%s\n", SERVER_IP);
} else if (!strcmp("SERVER_PORT", key)) {
sscanf(value, "%hu", &SERVER_PORT);
printf("PORT:%hu\n", SERVER_PORT);
} else if (!strcmp("LOG_SIZE", key)) {
sscanf(value, "%d", &LOG_SIZE);
printf("LOG_SIZE:%d\n", LOG_SIZE);
} else {
write_log("err: unknown config item, ignored.\n");
}
}
fclose(fp);
}
void *pa_malloc(size_t sz, bool is_executable)
{
int ret = 0;
void *pret = NULL;
size_t pagesz = (size_t)sysconf(_SC_PAGESIZE);
if(pagesz == -1) handle_err("sysconf");
if((ret = posix_memalign(&pret, pagesz, sz)) != 0)
handle_err_code("posix_memalign", ret);
if(is_executable) {
if((ret = mprotect(pret,sz,PROT_READ|PROT_WRITE|PROT_EXEC)) != 0)
handle_err("mprotect");
}
return pret;
}
void destroy() {
if (err_ == 0) return;
-- err_->refcount;
if (err_->refcount == 0) {
#ifndef NDEBUG
if (!err_->handled)
handle_err();
#endif
del();
}
}
int main(int argc, char const *argv[])
{
int listenfd, connfd;
int count;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
struct sigaction act, oact;
act.sa_handler = sig_chld;
act.sa_flags = SA_RESETHAND;
if (argc != 2) {
handle_err("usage: server <count>");
}
count = atoi(argv[1]);
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd == -1)
handle_err("socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
if (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 )
handle_err("binding error");
if (listen(listenfd, LISTEN_BACKLOG) == -1)
handle_err("listen error");
if (sigaction(SIGCHLD, &act, &oact) < 0) {
handle_err("waitpid error");
}
/* call accept, wait for a client */
for ( ; ; ) {
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
if (connfd == -1)
handle_err("accept error");
if ((childpid = fork()) < 0)
handle_err("fork error");
else if (childpid == 0) { /* child process */
close(listenfd);
read_data(connfd, count); /* process the request */
exit(0);
}
close(connfd); /* parent closes connected socket */
}
exit(EXIT_SUCCESS);
}
int main(int argc, char const *argv[])
{
int sockfd;
struct sockaddr_in cliaddr, servaddr;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1)
handle_err("socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
if (bind(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 )
handle_err("binding error");
/* process the request */
str_echo(sockfd, (struct sockaddr *) &cliaddr, sizeof(cliaddr));
exit(EXIT_SUCCESS);
}
void str_write(int sockfd)
{
ssize_t n;
char buf[MAXBYTES];
for ( ; ; ) {
while ((n = read(sockfd, buf, MAXBYTES)) > 0) {
write(STDOUT_FILENO, buf, n);
}
if (n < 0)
handle_err("read error");
}
}
void cli_str(int sockfd)
{
int n, m;
char sendline[MAXBYTES], recvline[MAXBYTES];
while ((n = read(STDIN_FILENO, sendline, MAXBYTES)) > 0) {
if (write(sockfd, sendline, n) == EOF) {
handle_err("write error to server");
}
if ((m = read(sockfd, recvline, MAXBYTES)) > 0)
write(STDOUT_FILENO, recvline, n);
}
}
int main(int argc, char *argv[])
{
int sockfd, count;
struct sockaddr_in servaddr;
if (argc != 2)
handle_err("usage: client <IP address>");
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
handle_err("socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(argv[1]);
servaddr.sin_port = htons(SERV_PORT);
if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
handle_err("connecting error");
cli_str(sockfd);
close(sockfd);
exit(EXIT_SUCCESS);
}
/*
Usage: ask user input the attribute from stdin, used by add and update
Return: none, directly modify the struct parameter
*/
void get_attr_input(struct name_prtl *pkt)
{
int n;
char buf[MAXBYTE];
char info[] = "Please input the attribute:\n"; /* used for write func */
write(STDIN_FILENO, info, sizeof(info));
if ((n = read(STDIN_FILENO, buf, MAXBYTE)) > 0) {
if ((pkt->data = (char *) malloc(n)) == NULL) {
handle_err("[Error] get_attr_input -- malloc error");
}
pkt->len = n;
strncpy(pkt->data, buf, n); /* copy the first n bytes */
}
}
void write_log(const char *str) {
time_t timep;
char s[30];
time(&timep);
strcpy(s, ctime(&timep));
fprintf(log_fp, "\ntime:%s things:%s\n", s, str);
fseek(log_fp, 0, SEEK_END);
unsigned fsize = ftell(log_fp);
if (fsize >= LOG_SIZE) {
fclose(log_fp);
sprintf(s, "./LOG/log_%d.txt", LOGFILE_CNT++);
log_fp = fopen(s, "w");
handle_err(log_fp == NULL, "create log file failed.");
}
}
void str_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)
{
ssize_t n;
socklen_t len;
char buf[MAXLINE];
for ( ; ; ) {
len = clilen;
while ((n = recvfrom(sockfd, buf, MAXLINE, 0, pcliaddr, &len)) > 0) {
sendto(sockfd, buf, n, 0, pcliaddr, len);
sendto(sockfd, buf, n, 0, pcliaddr, len);
}
if (n < 0)
handle_err("read error");
}
}
void str_cli(int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
int n = 50000;
int m;
char sendline[MAXLINE];
while ((m = sendto(sockfd, sendline, n, 0, pservaddr, servlen)) > 0
&& n < 100000) {
n++;
}
if (m == -1) {
if (errno == EMSGSIZE) {
printf("Largest UDP: %d\n", n);
}
handle_err("quit");
}
}
int main(int argc, char *argv[])
{
int sockfd, mss, val;
socklen_t optlen;
struct sockaddr_in servaddr;
if (argc != 2)
handle_err("usage: client <IP address>");
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
handle_err("socket error");
optlen = sizeof(mss);
val = getsockopt(sockfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &optlen);
if (val == -1) {
handle_err("getsockopt error");
} else {
printf("mss = %d\n", mss);
}
mss = 256;
val = setsockopt(sockfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss));
if (val == -1) {
handle_err("getsockopt error");
} else {
printf("set mss to %d\n", mss);
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(argv[1]);
servaddr.sin_port = htons(SERV_PORT);
if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
handle_err("connecting error");
val = getsockopt(sockfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &optlen);
if (val == -1) {
handle_err("getsockopt error");
} else {
printf("mss = %d\n", mss);
}
close(sockfd);
exit(EXIT_SUCCESS);
}
//main takes arguments from the commandline
int main(int argc,char*argv[])
{
GtkWidget*window;
GtkWidget*button1,*button3,*button4,*button5,*button6,*button7,*button8,*button9,*handle;
GtkWidget*picture1,*picture2,*label3,*label4,*label5,*label6,*label7,*label8,*label9,*label10,*label11,*label1,*label2;
GtkWidget*box1,*box2,*box3,*box4,*box5,*box6,*box7,*box8,*box9,*picture;
GtkWidget*image1,*image2,*image3,*image4,*image5,*image6,*image7,*image8,*image9,*lab1,*lab2,*lab3,*lab4;
GtkWidget*hbox1,*hbox2,*hbox3,*hbox4,*hbox5,*hbox6,*hbox7,*hbox8,*hbox9,*hbox11;
GtkWidget*vbox,*vbox1,*notebook,*fbox1,*fbox2,*fbox3,*fbox4,*pict1,*pict2,*pict3,*pict4;
GdkColor color1,color2,color3;
GtkWidget*but1,*but2,*but3,*but4;
GtkWidget*img1,*img2,*img3,*img4;
gtk_init(&argc,&argv);
if(!gtk_init_check(&argc,&argv))
{
handle_err("FAILED TO INITIALIZE THE GTK LIBRARIES");
}
//the following creats a window
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable(GTK_WINDOW(window),TRUE);
gtk_window_set_title(GTK_WINDOW(window),"GOSPEL BROWSER");
gtk_window_maximize(GTK_WINDOW(window));
gtk_window_present(GTK_WINDOW(window));
gtk_container_set_border_width(GTK_CONTAINER(window),0);
gtk_window_set_icon_from_file(GTK_WINDOW(window),"icon.jpg",NULL);
g_signal_connect(GTK_OBJECT(window),"destroy",G_CALLBACK(Close_Window),NULL);
//the following creats entry boxes
entry1=gtk_entry_new();
entry2=gtk_entry_new();
entry3=gtk_entry_new();
//reading a picture from the desktop
picture1=gtk_image_new_from_file("picture.jpg");
picture2=gtk_image_new_from_file("ogo.jpg");
gtk_widget_set_size_request(picture1,300,100);
//creating entry boxes
gtk_entry_set_text(GTK_ENTRY(entry1),"http//:");
gtk_entry_set_text(GTK_ENTRY(entry2),"search");
gtk_entry_set_text(GTK_ENTRY(entry3),"www.emmanuelTV.com");
//the lines of code below creats images from stock
image1=gtk_image_new_from_stock(GTK_STOCK_ADD,GTK_ICON_SIZE_MENU);
image2=gtk_image_new_from_stock(GTK_STOCK_CLOSE,GTK_ICON_SIZE_MENU);
image3=gtk_image_new_from_stock(GTK_STOCK_GO_BACK,GTK_ICON_SIZE_BUTTON);
image4=gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD,GTK_ICON_SIZE_BUTTON);
image5=gtk_image_new_from_stock(GTK_STOCK_FIND,GTK_ICON_SIZE_BUTTON);
image6=gtk_image_new_from_stock(GTK_STOCK_HOME,GTK_ICON_SIZE_BUTTON);
image7=gtk_image_new_from_file("search.jpg");
image8=gtk_image_new_from_stock(GTK_STOCK_GO_DOWN,GTK_ICON_SIZE_BUTTON);
image9=gtk_image_new_from_stock(GTK_STOCK_EXECUTE,GTK_ICON_SIZE_BUTTON);
//creates buttons
button1=gtk_button_new();
button2=gtk_button_new();
button3=gtk_button_new();
button4=gtk_button_new();
button5=gtk_button_new();
button6=gtk_button_new();
button7=gtk_button_new();
button8=gtk_button_new();
button9=gtk_button_new();
but1=gtk_button_new();
but2=gtk_button_new();
but3=gtk_button_new();
but4=gtk_button_new();
//box creation
box1=gtk_hbox_new(TRUE,0);
box2=gtk_hbox_new(TRUE,0);
box3=gtk_hbox_new(TRUE,0);
box4=gtk_hbox_new(TRUE,0);
box5=gtk_hbox_new(TRUE,0);
box6=gtk_hbox_new(TRUE,0);
box7=gtk_hbox_new(TRUE,0);
box8=gtk_hbox_new(TRUE,0);
box9=gtk_hbox_new(TRUE,0);
//the next lines adds the images to the buttons
gtk_box_pack_start_defaults(GTK_BOX(box1),image1);
gtk_container_add(GTK_CONTAINER(button1),box1);
gtk_widget_show_all(button1);
gtk_box_pack_start_defaults(GTK_BOX(box2),image2);
gtk_widget_set_size_request(box2,10,10);
gtk_container_add(GTK_CONTAINER(button2),box2);
gtk_widget_show_all(button2);
gtk_box_pack_start_defaults(GTK_BOX(box3),image3);
gtk_widget_set_size_request(box3,5,5);
gtk_container_add(GTK_CONTAINER(button3),box3);
gtk_widget_show_all(button3);
gtk_box_pack_start_defaults(GTK_BOX(box4),image4);
gtk_widget_set_size_request(box4,5,5);
gtk_container_add(GTK_CONTAINER(button4),box4);
gtk_widget_show_all(button4);
gtk_box_pack_start_defaults(GTK_BOX(box5),image5);
gtk_widget_set_size_request(box5,5,5);
gtk_container_add(GTK_CONTAINER(button5),box5);
gtk_widget_show_all(button5);
gtk_box_pack_start_defaults(GTK_BOX(box6),image6);
gtk_widget_set_size_request(box6,5,5);
gtk_container_add(GTK_CONTAINER(button6),box6);
gtk_widget_show_all(button6);
gtk_box_pack_start_defaults(GTK_BOX(box7),image7);
gtk_widget_set_size_request(box7,5,2);
gtk_container_add(GTK_CONTAINER(button7),box7);
gtk_widget_show_all(button7);
gtk_box_pack_start_defaults(GTK_BOX(box8),image8);
gtk_widget_set_size_request(box8,5,5);
gtk_container_add(GTK_CONTAINER(button8),box8);
gtk_widget_show_all(button8);
gtk_box_pack_start_defaults(GTK_BOX(box9),image9);
gtk_widget_set_size_request(box9,5,5);
gtk_container_add(GTK_CONTAINER(button9),box9);
gtk_widget_show_all(button9);
//this creats labels to be added in to the hboxes
label1=gtk_label_new(" ");
label2=gtk_label_new(" ");
label3=gtk_label_new("Gospel");
label4=gtk_label_new("");
label5=gtk_label_new(" ");
label6=gtk_label_new("");
label7=gtk_label_new(" ");
label8=gtk_label_new(" ");
label9=gtk_label_new(" ");
label10=gtk_label_new(" ");
label11=gtk_label_new(" ");
lab1=gtk_label_new(" ");
lab2=gtk_label_new(" ");
lab3=gtk_label_new(" ");
lab4=gtk_label_new(" ");
//color addiotion
gdk_color_parse("#CA29EF",&color1);
gdk_color_parse("#29EF2F",&color2);
gdk_color_parse("#2951EF",&color3);
//the function below changes the color of the labels specified
gtk_widget_modify_fg(label3,GTK_STATE_NORMAL,&color3);
/*creats hboxes abd vboxes to be added to the window*/
hbox1=gtk_hbox_new(FALSE,0);
hbox2=gtk_hbox_new(FALSE,0);
hbox3=gtk_hbox_new(FALSE,0);
hbox4=gtk_hbox_new(FALSE,3);
hbox5=gtk_hbox_new(TRUE,0);
hbox6=gtk_hbox_new(TRUE,0);
hbox7=gtk_hbox_new(TRUE,0);
hbox8=gtk_hbox_new(TRUE,0);
hbox9=gtk_hbox_new(TRUE,0);
hbox10=gtk_hbox_new(FALSE,0);
hbox11=gtk_hbox_new(TRUE,0);
//vertical boxes
vbox=gtk_vbox_new(FALSE,0);
vbox1=gtk_vbox_new(TRUE,0);
//creating event boxes
fbox1=gtk_hbox_new(TRUE,0);
fbox2=gtk_hbox_new(TRUE,0);
fbox3=gtk_hbox_new(TRUE,0);
fbox4=gtk_hbox_new(TRUE,0);
//crating picutres
pict1=gtk_image_new_from_file("joshua.jpg");
pict2=gtk_image_new_from_file("johnson.jpg");
pict3=gtk_image_new_from_file("chris.jpg");
pict4=gtk_image_new_from_file("Duncan.jpg");
//packing the images into the the event boxes
gtk_box_pack_start_defaults(GTK_BOX(fbox1),pict1);
gtk_widget_set_size_request(fbox1,65,30);
gtk_container_add(GTK_CONTAINER(but1),fbox1);
gtk_widget_show_all(but1);
gtk_box_pack_start_defaults(GTK_BOX(fbox2),pict2);
gtk_widget_set_size_request(fbox2,65,30);
gtk_container_add(GTK_CONTAINER(but2),fbox2);
gtk_widget_show_all(but2);
gtk_box_pack_start_defaults(GTK_BOX(fbox3),pict3);
gtk_widget_set_size_request(fbox3,100,30);
gtk_container_add(GTK_CONTAINER(but3),fbox3);
gtk_widget_show_all(but3);
gtk_box_pack_start_defaults(GTK_BOX(fbox4),pict4);
gtk_widget_set_size_request(fbox4,100,30);
gtk_container_add(GTK_CONTAINER(but4),fbox4);
gtk_widget_show_all(but4);
//the following uses box pack function to add buttons to the hboxes
gtk_box_pack_start_defaults(GTK_BOX(hbox1),button3);
g_object_set(button3,"relief",GTK_RELIEF_NONE,NULL);
gtk_box_pack_start_defaults(GTK_BOX(hbox1),button4);
g_object_set(button4,"relief",GTK_RELIEF_NONE,NULL);
gtk_box_pack_start_defaults(GTK_BOX(hbox1),entry1);
gtk_box_pack_start_defaults(GTK_BOX(hbox1),button5);
g_object_set(button5,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(button5),"clicked",G_CALLBACK(button_clicked),"button5");
gtk_box_pack_start_defaults(GTK_BOX(hbox1),entry2);
gtk_box_pack_start_defaults(GTK_BOX(hbox1),button6);
g_object_set(button6,"relief",GTK_RELIEF_NONE,NULL);
gtk_box_pack_start_defaults(GTK_BOX(hbox1),button9);
g_object_set(button9,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(button9),"clicked",GTK_SIGNAL_FUNC(upload_logo),"men_of_God");
gtk_box_pack_start_defaults(GTK_BOX(hbox1),button8);
g_object_set(button8,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(button8),"clicked",GTK_SIGNAL_FUNC(file_chooser),"download");
gtk_widget_set_size_request(hbox1,800,1);
gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox1);
gtk_box_pack_start_defaults(GTK_BOX(hbox9),label11);
gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox9);
gtk_box_pack_start_defaults(GTK_BOX(hbox2),label4);
gtk_box_pack_start_defaults(GTK_BOX(hbox2),picture1);
gtk_box_pack_start_defaults(GTK_BOX(hbox2),label5);
gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox2);
gtk_box_pack_start_defaults(GTK_BOX(hbox3),label1);
gtk_box_pack_start_defaults(GTK_BOX(hbox3),picture2);
gtk_box_pack_start_defaults(GTK_BOX(hbox3),entry3);
gtk_box_pack_start_defaults(GTK_BOX(hbox3),button7);
gtk_box_pack_start_defaults(GTK_BOX(hbox3),label2);
gtk_box_pack_start_defaults(GTK_BOX(hbox3),label8);
gtk_widget_set_size_request(button7,10,3);
gtk_widget_set_size_request(hbox3,100,20);
g_object_set(button7,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(button7),"clicked",GTK_SIGNAL_FUNC(button_clicked),"button7");
gtk_widget_set_size_request(hbox4,100,10);
gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox3);
gtk_box_pack_start_defaults(GTK_BOX(hbox4),lab1);
gtk_box_pack_start_defaults(GTK_BOX(hbox4),lab3);
gtk_box_pack_start_defaults(GTK_BOX(hbox4),but1);
g_object_set(but1,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(but1),"clicked",G_CALLBACK(generals_func),"Joshua");
gtk_box_pack_start_defaults(GTK_BOX(hbox4),but2);
g_object_set(but2,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(but2),"clicked",G_CALLBACK(generals_func),"Johnson");
gtk_box_pack_start_defaults(GTK_BOX(hbox4),but3);
g_object_set(but3,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(but3),"clicked",G_CALLBACK(generals_func),"Chris");
gtk_box_pack_start_defaults(GTK_BOX(hbox4),but4);
g_object_set(but4,"relief",GTK_RELIEF_NONE,NULL);
g_signal_connect(GTK_OBJECT(but4),"clicked",G_CALLBACK(generals_func),"Duncan");
gtk_box_pack_start_defaults(GTK_BOX(hbox4),lab2);
gtk_box_pack_start_defaults(GTK_BOX(hbox4),lab4);
gtk_widget_set_size_request(hbox4,100,150);
gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox4);
//the following creats a notebook
notebook=gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook),TRUE);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_TOP);
gtk_box_pack_start_defaults(GTK_BOX(hbox10),button2);
g_object_set(button2,"relief",GTK_RELIEF_NONE,NULL);
gtk_box_pack_start_defaults(GTK_BOX(hbox10),label3);
gtk_box_pack_start_defaults(GTK_BOX(hbox10),button1);
g_object_set(button1,"relief",GTK_RELIEF_NONE,NULL);
gtk_widget_show_all(hbox10);
gtk_widget_set_size_request(hbox10,150,35);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),vbox,hbox10);
g_signal_connect(GTK_OBJECT(button1),"clicked",G_CALLBACK(switch_page),(gpointer)notebook);
g_signal_connect(GTK_OBJECT(button2),"clicked",G_CALLBACK(CloseApp),(gpointer)notebook);
gtk_rc_parse("gosple.gtkrc");
//changes the sizes of some widgets
gtk_widget_set_size_request(entry1,750,27);
gtk_widget_set_size_request(button3,20,10);
gtk_widget_set_size_request(button4,20,10);
gtk_widget_set_size_request(button5,20,10);
gtk_widget_set_size_request(button6,20,10);
gtk_widget_set_size_request(button8,20,10);
gtk_widget_set_size_request(entry3,400,27);
gtk_widget_set_size_request(entry2,200,27);
//adds the notebook to a contiainer
gtk_container_add(GTK_CONTAINER(window),notebook);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main(int argc, char *argv[])
{
int sockfd, hostfd;
int flags, opt, i, n, m;
char serv_name[MAXHOSTNAME];
char port[MAXPORTSIZE];
char name[MAXNAMESIZE + 1];
struct name_prtl request;
// get options
flags = 0;
name[0] = '\0';
while ((opt = getopt(argc, argv, "adlun:")) != -1) {
switch (opt) {
case 'l': /* lookup */
if (flags != 0) {
fprintf(stderr, "[Error] you should only specify one type of ");
fprintf(stderr, "operations from add, lookup, delete and update\n");
exit(EXIT_FAILURE);
}
flags = 1;
break;
case 'a': /* add */
if (flags != 0) {
fprintf(stderr, "[Error] you should only specify one type of ");
fprintf(stderr, "operations from add, lookup, delete and update\n");
exit(EXIT_FAILURE);
}
flags = 2;
break;
case 'd': /* delete */
if (flags != 0) {
fprintf(stderr, "[Error] you should only specify one type of ");
fprintf(stderr, "operations from add, lookup, delete and update\n");
exit(EXIT_FAILURE);
}
flags = 3;
break;
case 'u': /* update */
if (flags != 0) {
fprintf(stderr, "[Error] you should only specify one type of ");
fprintf(stderr, "operations from add, lookup, delete and update\n");
exit(EXIT_FAILURE);
}
flags = 4;
break;
case 'n': /* name */
n = strlen(optarg);
if (n > MAXNAMESIZE) {
fprintf(stderr,
"[Error] the name is too long, its maxsize is %d\n", MAXNAMESIZE);
exit(EXIT_FAILURE);
}
// copy the input string to name[]
for (i = 0; i < n; i++) {
name[i] = optarg[i];
}
for ( ; i < MAXNAMESIZE + 1; i++) {
name[i] = '\0';
}
break;
default: /* ? */
fprintf(stderr, "[Usage] %s [-adlu] [-n name]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
// check input parameters
if (flags == 0 || name[0] == '\0') {
fprintf(stderr, "[Error] missing args\n");
fprintf(stderr, "[Usage] %s [-adlu] [-n name]\n", argv[0]);
exit(EXIT_FAILURE);
}
if (!((name[0] >= 48 && name[0] <= 57) || (name[0] >= 65 && name[0] <= 90)
|| (name[0] >= 97 && name[0] <= 122))) {
fprintf(stderr, "[Error] illegal name\n ");
fprintf(stderr, "the name should begin with a letter or a number\n");
exit(EXIT_FAILURE);
}
// open the server config file
if ((hostfd = open(CONF_FILE, O_RDONLY)) < 0) {
handle_err("Open config file error");
}
if ((m = get_server_info(hostfd, serv_name, port)) == -1) {
fprintf(stderr, "Error: failed to parse server name and port\n");
exit(EXIT_FAILURE);
}
// connect to name server with timeout
sockfd = tcp_connect(serv_name, port); /* tcp_connect in func_wrapper */
if (sockfd == -1) {
fprintf(stderr, "[Error] failed to connect to the server\n");
exit(EXIT_FAILURE);
}
// initialize the request pkt
request.protocol = 1;
request.type = flags;
strncpy(request.name, name, MAXNAMESIZE + 1);
if (flags == 1 || flags == 3) {
request.len = 0;
} else {
get_attr_input(&request); /* get the attribute string */
}
/* client */
name_service(sockfd, &request);
close(sockfd);
exit(EXIT_SUCCESS);
}
int main(){
struct sockaddr_in serveraddr;
struct sockaddr_in clientaddr;
int sockfd;
int connfd;
int addrlen;
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0){
handle_err("socket error\n");
}
bzero(&serveraddr,sizeof(struct sockaddr_in));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(PORT);
int optval = 1;
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(optval));
if(bind(sockfd,(struct sockaddr *)&serveraddr,sizeof(struct sockaddr_in))==-1){
close(sockfd);
handle_err("bind error\n");
}
if(listen(sockfd,128)==-1){
close(sockfd);
handle_err("listen error\n");
}
addrlen = sizeof(struct sockaddr);
connfd = accept(sockfd,(struct sockaddr *)&clientaddr,&addrlen);
if(connfd==-1){
close(sockfd);
handle_err("accept error\n");
}
printf("client %s connected\n",inet_ntoa(clientaddr.sin_addr));
pid_t pid = fork();
if(pid==0){
signal(SIGUSR1,handle_sig);
char send_buf[1024] = {0};
while(fgets(send_buf,sizeof(send_buf),stdin)!=NULL){
write(connfd,send_buf,strlen(send_buf));
memset(send_buf,0,sizeof(send_buf));
}
}else if(pid>0){
char recv_buf[1024] = {0};
while(1){
int len = read(connfd,recv_buf,sizeof(recv_buf));
if(len==-1){
close(sockfd);
close(connfd);
handle_err("read error\n");
}else if(len==0){
printf("client close\n");
break;
}else{
fputs(recv_buf,stdout);
memset(recv_buf,0,sizeof(recv_buf));
}
}
}else{
close(connfd);
close(sockfd);
handle_err("fork error\n");
}
kill(pid,SIGUSR1);
close(connfd);
close(sockfd);
return 0;
}
int main(int argc, char *argv[])
{
int listenfd, connfd, dbfd, itemfd, rservfd, logfd;
int dflag, iflag, opt, n, i;
int port = 0;
pid_t childpid;
char *database, *nameitem, *logfile;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
struct sigaction act1, oact1, act2, oact2;
act1.sa_handler = sig_chld;
act1.sa_flags = SA_RESETHAND;
act2.sa_handler = sig_int;
act2.sa_flags = SA_RESETHAND;
dflag = iflag = 0; /* parameter parer flag, unset at the beginning */
// parameter parser using getopt
while ((opt = getopt(argc, argv, "d:i:p:")) != -1) {
switch (opt) {
case 'd': /* database file path */
n = strlen(optarg);
// copy the input string content to a new string
if ((database = (char *) malloc(n + 1)) == NULL) {
handle_err("[Error] main -- malloc error");
}
for (i = 0; i < n; i++) {
database[i] = optarg[i];
}
database[i] = '\0';
dflag = 1; /* has been set */
break;
case 'i': /* nameindex file path */
n = strlen(optarg);
// copy the input string content to a new string
if ((nameitem = (char *) malloc(n + 1)) == NULL) {
handle_err("[Error] main -- malloc error");
}
for (i = 0; i < n; i++) {
nameitem[i] = optarg[i];
}
nameitem[i] = '\0';
iflag = 1;
break;
case 'p': /* server port number */
port = atoi(optarg);
if (port < 65535 && port > 1024) {
fprintf(stderr, "[Error] main -- illegal port number\n");
exit(EXIT_FAILURE);
}
break;
default: /* ? */
fprintf(stderr, "[Usage] %s [-d filepath] [-r filepath]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
if (dflag == 0) { // not input database path
if (generate_filename(&database, ".db") < 0) {
fprintf(stderr, "[Error] generate_filename error\n");
exit(EXIT_FAILURE);
}
}
if (iflag == 0) { // not input name index path
if (generate_filename(&nameitem, ".index") < 0) {
fprintf(stderr, "[Error] generate_filename error\n");
exit(EXIT_FAILURE);
}
}
if (generate_filename(&logfile, ".log") < 0) {
fprintf(stderr, "[Error] generate_filename error\n");
exit(EXIT_FAILURE);
}
// open needed file
if ((dbfd = open(database, O_RDWR | O_APPEND | O_CREAT,
S_IRUSR | S_IWUSR)) < 0) {
handle_err("[Error] main -- open or create database file error");
}
if ((itemfd = open(nameitem, O_RDWR | O_APPEND | O_CREAT,
S_IRUSR | S_IWUSR)) < 0) {
handle_err("[Error] main -- open or create nameindex table file error");
}
if ((rservfd = open(ROUTE_SERVER, O_RDONLY)) < 0) {
handle_err("[Error] main -- open routeserver config file error");
}
if ((logfd = open(logfile, O_RDWR | O_APPEND | O_CREAT,
S_IRUSR | S_IWUSR)) < 0) {
handle_err("[Error] main -- open or create log file error");
}
// initialize the socket and listen to request
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd == -1)
handle_err("[Error] main -- socket error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (port == 0) {
port = SERV_PORT;
}
servaddr.sin_port = htons(port);
if (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 )
handle_err("binding error");
if (listen(listenfd, LISTEN_BACKLOG) == -1)
handle_err("listen error");
// signal handler
if (sigaction(SIGCHLD, &act1, &oact1) < 0) {
handle_err("sig_chld error");
}
if (sigaction(SIGINT, &act2, &oact2) < 0) {
handle_err("sig_int error");
}
/* call accept, wait for a client */
for ( ; ; ) {
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
if (connfd < 0) {
if (errno == EINTR) {
continue;
} else {
handle_err("accept error");
}
}
if ((childpid = fork()) < 0)
handle_err("fork error");
else if (childpid == 0) { /* child process */
close(listenfd);
/* process the request */
name_server(connfd, dbfd, itemfd, rservfd, logfd, port);
exit(0);
}
close(connfd); /* parent closes connected socket */
}
exit(EXIT_SUCCESS);
}
void posib_handle_err() const {
#ifndef NDEBUG
if (err_ && !err_->handled)
handle_err();
#endif
}
/*
Usage: main func after connecting to server, send request, interprate reply
Return: none
*/
void name_service(int sockfd, struct name_prtl *pkt)
{
char *data, *str;
char buf[MAXBYTE];
int len, n, i;
struct name_prtl reply;
/* alloc memory for request pkt, the name_prtl struct can not be send
directly: 1) binary type may have different bit order
2) unfixed string in the struct
here we need to transform the struct into a text string
*/
len = 38 + pkt->len + 1;
if ((data = (char *) malloc(len)) == NULL) {
handle_err("[Error] name_service -- malloc error");
}
// transform the pkt struct to a text string
gen_name_pkt(pkt, data);
// send the text string
if (write(sockfd, data, len) == -1) {
handle_err("[Error] name_service -- write error to server");
}
// socket read with timeout
if ((n = read_timeo(sockfd, buf, MAXBYTE, TRANS_TIMEO)) < 0) {
fprintf(stderr, "[Error] name_service -- read_timeo error");
} else if (n == 0) {
fprintf(stderr, "[Error] name_service -- read timeout");
}
if (buf[0] != '1') {
fprintf(stderr, "[Error] name_service -- receive unknown pkt\n");
return;
}
// alloc mem for parsing the pkt
if ((str = (char *) malloc(n + 1)) == NULL) {
handle_err("[Error] name_service -- malloc error");
}
for (i = 0; i < n; i ++) { /* copy the text data */
str[i] = buf[i];
}
str[i] = '\0';
// initialize the reply pkt structure
reply.protocol = 1;
if ((n = parse_name_pkt(&reply, str)) == -1) {
fprintf(stderr, "[Error] name_service -- fail to parse pkt\n");
return;
}
// check the names of request and reply
if (strcmp(reply.name, pkt->name) != 0) {
printf("[Error] name_service -- unmatching reply\n");
return;
}
// print message data get from server
if (reply.type == 5) {
printf("[Info] attribute: ");
} else if (reply.type == 6 || reply.type == 7) {
printf("[Info] ");
} else {
printf("[Error] ");
}
printf("%s\n", reply.data);
}
