[文件] i.h ~ 5KB 下载(938)
001 | /* |
002 | *i.h is a used for creating a library |
003 | *for server client |
004 | *Mar 18 2010 |
005 | * |
006 | */ |
007 | #ifndef _I_H |
008 | |
009 | #define _I_H |
010 | |
011 | #include <math.h> |
012 | #include <stdio.h> |
013 | #include <sys/socket.h> |
014 | #include <arpa/inet.h> |
015 | #include <netinet/in.h> |
016 | #include <unistd.h> |
017 | #include <sys/types.h> |
018 | #include <sys/stat.h> |
019 | #include <fcntl.h> |
020 | #include <stdlib.h> |
021 | #include <errno.h> |
022 | #include <string.h> |
023 | #include <inttypes.h> |
024 | #include <time.h> |
025 | #include <sys/ioctl.h> |
026 | #include <net/if.h> |
027 | #include <signal.h> |
028 | #include <ncurses.h> |
029 | #include <math.h> |
030 | |
031 | #define SEVR_IP "127.0.0.1" |
032 | #define SEVR_PORT 8081 |
033 | #define CNTNT_LEN 150 |
034 | #define MSG_LEN sizeof(struct msg) |
035 | #define ADDR_LEN sizeof(struct sockaddr) |
036 | #define USR_LEN sizeof(struct user) |
037 | #define PRT_LEN 8 |
038 | #define HSTR_LEN sizeof(struct chat_history) |
039 | |
040 | /* declare Global variables */ |
041 | int mainfd; /* used as chat histroy file handle*/ |
042 | int sockfd; /* used as socket local handle */ |
043 | int count; |
044 | struct sockaddr_in server; |
045 | |
046 | /* msg is used for communicating message */ |
047 | struct msg |
048 | { |
049 | int flag; /* flag meaning:1,ordinary; 2,log msg; 3,reg msg, other,file*/ |
050 | int id_from; |
051 | int id_to; |
052 | char content[CNTNT_LEN]; |
053 | char append[10]; |
054 | }; |
055 | |
056 | /* user is used information list */ |
057 | struct user |
058 | { |
059 | int id; |
060 | char name[10]; |
061 | char password[10]; |
062 | char *p_chatlog; |
063 | struct sockaddr user_addr; |
064 | }; |
065 | /* chat_history used for reading chat history */ |
066 | struct chat_history |
067 | { |
068 | char content[CNTNT_LEN]; |
069 | char time [25]; |
070 | int to; |
071 | int from; |
072 | int count; |
073 | }; |
074 | |
075 | /* i_functions below is funtions needed by both client and sever */ |
076 | extern int i_saveto_chat( struct msg *pmsg); |
077 | |
078 | int i_clean_stdin () |
079 | { |
080 | while ( '\n' == getchar ()) |
081 | { |
082 | continue ; |
083 | } |
084 | |
085 | return (0); |
086 | } |
087 | |
088 | int i_print( char *pmsg, int size) |
089 | { |
090 | int i = 1; |
091 | |
092 | for (i; i<= size; i++) |
093 | { |
094 | if (*pmsg != '\n' ) |
095 | { |
096 | printf ( "%c" , *pmsg); |
097 | pmsg ++; |
098 | } |
099 | else |
100 | { |
101 | return (0); |
102 | } |
103 | } |
104 | |
105 | return (0); |
106 | } |
107 | int i_input( char *p_input) |
108 | { |
109 | char c = '\0' ; |
110 | int i; |
111 | |
112 | for (i = 0; i < CNTNT_LEN; i++) |
113 | { |
114 | p_input[i] = getchar (); |
115 | if (p_input[i] == '\n' ) |
116 | { |
117 | return (0); |
118 | } |
119 | } |
120 | |
121 | printf ( "you have input long enough!\n" ); |
122 | return (0); |
123 | } |
124 | int i_socket( int domain, int type, int protocol) |
125 | { |
126 | int fd; |
127 | |
128 | if ((fd = socket(domain, type, protocol)) == -1) |
129 | { |
130 | perror ( "creat socket error:" ); |
131 | exit (1); |
132 | } |
133 | |
134 | return (fd); |
135 | } |
136 | |
137 | int i_bind( int fd, const struct sockaddr *addr, int namelen) |
138 | { |
139 | if (-1 == bind(fd, addr, namelen)) |
140 | { |
141 | perror ( "i_bind error:" ); |
142 | exit (1); |
143 | } |
144 | |
145 | return (0); |
146 | } |
147 | |
148 | int i_recvfrom( int fd, void *buf, size_t len, int flags, |
149 | struct sockaddr *addr, int *size) |
150 | { |
151 | if (-1 == recvfrom(fd, buf, len, flags, addr, size)) |
152 | { |
153 | perror ( "i_recvfrom error:" ); |
154 | exit (1); |
155 | } |
156 | |
157 | return (0); |
158 | } |
159 | |
160 | int i_sendto( int fd, void *buf, size_t len, int flags, |
161 | struct sockaddr *addr, int size) |
162 | { |
163 | if (-1 == sendto(fd, buf, len, flags, addr, size)) |
164 | { |
165 | perror ( "i_sendto error" ); |
166 | exit (1); |
167 | } |
168 | |
169 | return (0); |
170 | } |
171 | |
172 | int i_open( const char *pathname, int flags) |
173 | { |
174 | int fd; |
175 | if ((fd = open(pathname, flags)) == -1) |
176 | { |
177 | perror ( "open_failed" ); |
178 | exit (1); |
179 | } |
180 | |
181 | return (fd); |
182 | } |
183 | int i_read( int fd, void *msg, int len) |
184 | { |
185 | if (-1 == read(fd, msg, len)) |
186 | { |
187 | perror ( "i_read error" ); |
188 | exit (1); |
189 | } |
190 | return (0); |
191 | } |
192 | int i_write( int fd, void *msg, int len) |
193 | { |
194 | if (-1 == write(fd, msg, len)) |
195 | { |
196 | perror ( "i_write error" ); |
197 | exit (0); |
198 | } |
199 | return (0); |
200 | } |
201 | |
202 | /* init a socket,file and server addr */ |
203 | int i_init() |
204 | { |
205 | mainfd = i_open( "./chat_log" , O_RDWR|O_CREAT); |
206 | sockfd = i_socket(AF_INET, SOCK_DGRAM, 0); |
207 | |
208 | /* initialize server address */ |
209 | bzero(&server, sizeof (server)); |
210 | server.sin_family = AF_INET; |
211 | inet_pton(AF_INET, "127.0.0.1" , &server.sin_addr); |
212 | server.sin_port = htons(SEVR_PORT); |
213 | |
214 | perror ( "init" ); |
215 | |
216 | return (0); |
217 | } |
218 | |
219 | char *i_get_time() |
220 | { |
221 | time_t time_now; |
222 | time (&time_now); |
223 | |
224 | return ( ctime (&time_now)); |
225 | } |
226 | int i_lseek( int fd, off_t size, int position) |
227 | { |
228 | if (-1 == lseek(fd, size, position)) |
229 | { |
230 | perror ( "seek error" ); |
231 | exit (1); |
232 | } |
233 | return (0); |
234 | } |
235 | int i_saveto_chat( struct msg *pmsg) |
236 | { |
237 | struct chat_history hstr; |
238 | |
239 | |
240 | bzero(&hstr, HSTR_LEN); |
241 | count = count + 1; |
242 | hstr.count =count; |
243 | hstr.from = pmsg->id_from; |
244 | hstr.to = pmsg->id_to; |
245 | strncpy (hstr.content, pmsg->content, CNTNT_LEN); |
246 | strncpy (hstr. time , i_get_time(), 25); |
247 | |
248 | i_lseek(mainfd, 0, SEEK_END); |
249 | |
250 | i_write(mainfd, &hstr, HSTR_LEN); |
251 | |
252 | return (0); |
253 | } |
254 | |
255 | int i_print_history( int len, int i) |
256 | { |
257 | struct chat_history chat_reader; |
258 | int j; |
259 | int position; |
260 | |
261 | bzero(&chat_reader, HSTR_LEN); |
262 | if (i != 0) |
263 | { |
264 | position = len*i*HSTR_LEN; |
265 | i_lseek(mainfd, position, SEEK_END); |
266 | } |
267 | else |
268 | { |
269 | position = len*i*HSTR_LEN; |
270 | |
271 | i_lseek(mainfd, HSTR_LEN, SEEK_SET); |
272 | } |
273 | |
274 | for (j = 1; j <= len; j++) |
275 | { |
276 | |
277 | i_read(mainfd, &chat_reader, HSTR_LEN); |
278 | printf ( "\n#item%d:id%dto id%d \n" , j, |
279 | chat_reader.from, chat_reader.to); |
280 | i_print(chat_reader.content, CNTNT_LEN); |
281 | printf ( "\n Time:%s\n" , chat_reader. time ); |
282 | } |
283 | |
284 | return (0); |
285 | } |
286 | |
287 | #endif |
[文件] server.c ~ 6KB 下载(635)
001 | /* |
002 | *title:server.c |
003 | *content:server part |
004 | *start time: Mar.25.2011 |
005 | *end time: Apr.8 2011 |
006 | */ |
007 | |
008 | #include "i.h" |
009 | |
010 | int user_list_fd; |
011 | |
012 | /* start:initialization */ |
013 | int init() |
014 | { |
015 | i_init(); |
016 | |
017 | user_list_fd = i_open( "./user_list" , O_RDWR|O_CREAT); |
018 | |
019 | struct user usr; |
020 | /* init the user list file's fist user to 0*/ |
021 | memset (( struct user*)&usr, '\0' , sizeof ( struct user)); |
022 | i_lseek(user_list_fd, 0, SEEK_SET); |
023 | i_write(user_list_fd, ( char *)&usr, USR_LEN); |
024 | |
025 | /* bind the struct sockaddr_in server to the sockfd */ |
026 | i_bind(sockfd, ( struct sockaddr*)&server, ADDR_LEN); |
027 | |
028 | struct chat_history apple; |
029 | |
030 | bzero(&apple, HSTR_LEN); |
031 | i_lseek(mainfd, 0, SEEK_SET); |
032 | i_write(mainfd, &apple, HSTR_LEN); |
033 | i_lseek(mainfd, -HSTR_LEN, SEEK_END); |
034 | i_read(mainfd, &apple, HSTR_LEN); |
035 | count = apple.count; |
036 | |
037 | return (0); |
038 | } |
039 | /* end:initialization */ |
040 | |
041 | /* start:message control */ |
042 | int send_msg( struct msg *msg_recv, struct sockaddr *addr) |
043 | { |
044 | int i; |
045 | struct user usr; |
046 | |
047 | /* a common message come */ |
048 | printf ( "a ordinar message come !\n" ); |
049 | |
050 | i = msg_recv->id_to; |
051 | i_lseek(user_list_fd, i*USR_LEN, SEEK_SET); |
052 | i_read(user_list_fd, &usr, USR_LEN); |
053 | strncpy (msg_recv->append, usr.name, 10); |
054 | |
055 | i_sendto(sockfd, msg_recv, MSG_LEN, 0, |
056 | &(usr.user_addr), ADDR_LEN); |
057 | |
058 | printf ( "id%d send a message to id%d sucess!\n" , msg_recv->id_from, msg_recv->id_to); |
059 | |
060 | return (0); |
061 | } |
062 | int check_login( struct msg *msg_recv, struct sockaddr *addr) |
063 | { |
064 | int i = msg_recv->id_from;; |
065 | struct user usr; |
066 | |
067 | /* a login requet */ |
068 | printf ( "a login request come!\n" ); |
069 | |
070 | /* get the id's information */ |
071 | i_lseek(user_list_fd, i*USR_LEN, SEEK_SET); |
072 | i_read(user_list_fd, &usr, USR_LEN); |
073 | |
074 | int n; |
075 | n = strcmp (usr.password, msg_recv->content); |
076 | /* 如果验证成功,则发送成功信息 */ |
077 | if (n == 0) |
078 | { |
079 | /* save user new address */ |
080 | i_lseek(user_list_fd, -USR_LEN, SEEK_CUR); |
081 | usr.user_addr = *addr; |
082 | i_write(user_list_fd, &usr, USR_LEN); |
083 | /* tell user pass */ |
084 | i_sendto(sockfd, ( struct msg*)msg_recv, sizeof ( struct msg), 0, |
085 | &(usr.user_addr), ADDR_LEN); |
086 | |
087 | } |
088 | else |
089 | { |
090 | /* 出错的话的respond */ |
091 | if (0 != n) |
092 | { |
093 | printf ( "id %d login error.\n" , i); |
094 | bzero(msg_recv->content, CNTNT_LEN); |
095 | msg_recv->flag = -1; |
096 | i_sendto(sockfd, ( struct msg*)msg_recv, sizeof ( struct msg), 0, |
097 | &(usr.user_addr), ADDR_LEN); |
098 | |
099 | } |
100 | return (1); |
101 | } |
102 | printf ( "Id %d login sucess!\n" , i); |
103 | |
104 | return (0); |
105 | } |
106 | int reg_user( struct msg *msg_recv, struct sockaddr *addr) |
107 | { |
108 | struct user usr; |
109 | |
110 | printf ( "a regit requet come:\n" ); |
111 | |
112 | /* find the last user and hava the please to add a new user */ |
113 | int n; |
114 | i_lseek(user_list_fd, -USR_LEN, SEEK_END); |
115 | i_read(user_list_fd, &usr, USR_LEN); |
116 | /* 把新用户的信息赋值到usr然后填入到user list file中 */ |
117 | const char *name; |
118 | const char *password; |
119 | |
120 | name = &(msg_recv->content[0]); |
121 | password = &(msg_recv->content[10]); |
122 | strcpy ((usr.name), name); |
123 | strcpy (usr.password, password); |
124 | memcpy (&(usr.user_addr),addr, ADDR_LEN); |
125 | |
126 | usr.id = (usr.id + 1); |
127 | i_lseek(user_list_fd, 0, SEEK_END); |
128 | i_write(user_list_fd, &usr, USR_LEN); |
129 | |
130 | msg_recv->id_from = usr.id; |
131 | /* regist to the user list then tell the user reg success */ |
132 | i_sendto(sockfd, ( struct msg*)msg_recv, sizeof ( struct msg), 0, |
133 | addr, ADDR_LEN); |
134 | |
135 | printf ( "Id %d regist sucess!\n" , usr.id); |
136 | |
137 | return (0); |
138 | |
139 | } |
140 | int msg_cntl() |
141 | { |
142 | struct msg msg_recv; |
143 | struct sockaddr addr_recv; |
144 | |
145 | printf ( "begin listen input...\n" ); |
146 | int size = ADDR_LEN; |
147 | |
148 | for (;;) |
149 | { |
150 | bzero(&msg_recv, MSG_LEN); |
151 | i_recvfrom(sockfd, &msg_recv, sizeof ( struct msg), 0, |
152 | &addr_recv, &size); |
153 | printf ( "message received...\n" ); |
154 | |
155 | i_saveto_chat(&msg_recv); |
156 | |
157 | switch (msg_recv.flag) |
158 | { |
159 | case 1 : |
160 | send_msg(&msg_recv,( struct sockaddr*)&addr_recv); /* send ordinary chat */ |
161 | break ; |
162 | case 2 : |
163 | check_login(&msg_recv, ( struct sockaddr*)&addr_recv); |
164 | break ; |
165 | case 3 : |
166 | reg_user(&msg_recv, ( struct sockaddr*)&addr_recv); |
167 | break ; |
168 | default : |
169 | break ; |
170 | } |
171 | } |
172 | return (0); |
173 | } |
174 | /* end:message control*/ |
175 | /* start:exit_sys()*/ |
176 | int exit_sys() |
177 | { |
178 | close(sockfd); |
179 | close(mainfd); |
180 | close(user_list_fd); |
181 | printf ( "exit system" ); |
182 | kill(0, SIGABRT); |
183 | |
184 | exit (0); |
185 | } |
186 | /* end:exit_sys()*/ |
187 | |
188 | /* start:chat_history*/ |
189 | int get_page_size() |
190 | { |
191 | struct chat_history page_size_reader; |
192 | |
193 | i_lseek(mainfd, -HSTR_LEN, SEEK_END); |
194 | i_read(mainfd, &page_size_reader, HSTR_LEN); |
195 | |
196 | return (page_size_reader.count); |
197 | } |
198 | |
199 | int read_chat_history() |
200 | { |
201 | printf ( "****char*history***" ); |
202 | printf ( "(n-nextpage; p-prepage; q-quit)\n" ); |
203 | |
204 | int page_num; /* */ |
205 | int remains; |
206 | int berry = get_page_size(); |
207 | |
208 | |
209 | page_num = berry / 8; |
210 | remains = berry % 8; |
211 | |
212 | if (remains != 0) |
213 | page_num ++; |
214 | else |
215 | page_num = page_num; |
216 | |
217 | printf ( "there are %d page total %d items" , |
218 | page_num, berry); |
219 | |
220 | int i = -1; |
221 | |
222 | while (1) |
223 | { |
224 | char flag; |
225 | |
226 | if ((berry + i*8) >= 0) |
227 | { |
228 | printf ( "(%d~%d)\n" , (berry + i*8), (berry + (i+1)*8)); |
229 | |
230 | i_print_history(PRT_LEN, i); |
231 | |
232 | printf ( "@@@\n" ); |
233 | while ( '\n' == (flag = getchar ())) |
234 | { |
235 | } |
236 | |
237 | switch (flag) |
238 | { |
239 | case 'p' : |
240 | i--; |
241 | break ; |
242 | case 'n' : |
243 | i++; |
244 | break ; |
245 | case 'q' : |
246 | return (0); |
247 | default : |
248 | break ; |
249 | } |
250 | if (i >= 0) |
251 | { |
252 | printf ( "have at the end!\n" ); |
253 | printf ( "return to menu!\n" ); |
254 | } |
255 | } |
256 | else |
257 | { |
258 | printf ( "(1~%d)\n" , remains); |
259 | |
260 | i_print_history(remains, 0); |
261 | |
262 | printf ( "#########over##############\n" ); |
263 | |
264 | return (0); |
265 | } |
266 | } |
267 | |
268 | return (0); |
269 | } |
270 | /* end:chat_history*/ |
271 | /* start:menu*/ |
272 | int menu() |
273 | { |
274 | sleep(1); |
275 | |
276 | printf ( "----------help----menu---------\n" ); |
277 | printf ( "\t r--report to user\n" ); |
278 | printf ( "\t c--chat history\n" ); |
279 | printf ( "\t h--help menu\n" ); |
280 | printf ( "\t e--exit the system\n" ); |
281 | printf ( "----------help_menu---------\n" ); |
282 | |
283 | int command = 0; |
284 | |
285 | printf ( "input command>" ); |
286 | command = getchar (); |
287 | switch (command) |
288 | { |
289 | |
290 | case 'c' : |
291 | read_chat_history(); |
292 | break ; |
293 | case 'e' : |
294 | exit_sys(); |
295 | break ; |
296 | case 'r' : |
297 | //report(); |
298 | //break; |
299 | default : |
300 | menu(); |
301 | break ; |
302 | } |
303 | getchar (); |
304 | |
305 | return (0); |
306 | } |
307 | /* end:menu*/ |
308 | int main() |
309 | { |
310 | init(); |
311 | pid_t pid; |
312 | switch (pid = fork()) |
313 | { |
314 | case -1 : |
315 | perror ( "fork error\n" ); |
316 | exit (1); |
317 | break ; |
318 | case 0 : |
319 | msg_cntl(); |
320 | break ; |
321 | default : |
322 | menu(); |
323 | break ; |
324 | } |
325 | |
326 | return (0); |
327 | } |
[文件] client.c ~ 8KB 下载(643)
001 | /* |
002 | *title: client.c |
003 | *start_time: Mar.18 2011 |
004 | *end_time: Apr.8 2011 |
005 | */ |
006 | |
007 | #include "i.h" |
008 | |
009 | #define START_PORT 8089 |
010 | |
011 | struct sockaddr_in my_addr; |
012 | int my_id; |
013 | |
014 | int my_log(); /* declare funtion*/ |
015 | |
016 | /* */ |
017 | int i_send_msg() |
018 | { |
019 | int id; |
020 | struct msg the_msg; |
021 | char end = '@' ; |
022 | |
023 | printf ( "input recver id:" ); |
024 | scanf ( "%d" , &id); |
025 | getchar (); |
026 | printf ( "\ninput content:" ); |
027 | i_input(the_msg.content); |
028 | |
029 | char flag = 'y' ; |
030 | |
031 | if (1) |
032 | { |
033 | the_msg.flag = 1; |
034 | the_msg.id_from = my_id; |
035 | the_msg.id_to = id; |
036 | |
037 | i_sendto(sockfd, &the_msg, sizeof ( struct msg), 0, |
038 | ( struct sockaddr*)&server, sizeof ( struct sockaddr)); |
039 | |
040 | i_saveto_chat(&the_msg); /* save to history */ |
041 | |
042 | printf ( "send to id:%d success.\n" , my_id); |
043 | return (0); |
044 | } |
045 | else |
046 | return (1); |
047 | |
048 | return (0); |
049 | } |
050 | |
051 | int reply() |
052 | { |
053 | return (0); |
054 | } |
055 | int send_file() |
056 | { |
057 | return (0); |
058 | } |
059 | /**/ |
060 | /* start:initialize */ |
061 | int init() |
062 | { |
063 | struct ifreq req; |
064 | struct sockaddr_in *host; |
065 | int port; |
066 | |
067 | i_init(); |
068 | /* init user addr */ |
069 | bzero(&my_addr, sizeof ( struct sockaddr)); |
070 | my_addr.sin_family = AF_INET; |
071 | strcpy (req.ifr_name, "lo" ); |
072 | if ( ioctl(sockfd, SIOCGIFADDR, &req) < 0 ) /* get local ip address */ |
073 | { |
074 | perror ( "get local ip error" ); |
075 | exit (1); |
076 | } |
077 | |
078 | host = ( struct sockaddr_in*)&(req.ifr_addr); |
079 | printf ( "ip: %s\n" , inet_ntoa(host->sin_addr)); |
080 | |
081 | memcpy (&my_addr, ( struct sockaddr_in*)&(req.ifr_addr), |
082 | sizeof ( struct sockaddr_in)); |
083 | |
084 | port = START_PORT; |
085 | |
086 | do |
087 | { |
088 | port++; |
089 | my_addr.sin_port = htons(port); |
090 | bind(sockfd, ( struct sockaddr*)&my_addr, |
091 | sizeof ( struct sockaddr)); |
092 | } |
093 | while ( errno == EADDRINUSE); |
094 | |
095 | struct chat_history apple; |
096 | |
097 | memset (&apple, 'b' , HSTR_LEN); |
098 | i_lseek(mainfd, 0, SEEK_SET); |
099 | apple.count = 0; |
100 | i_write(mainfd, &apple, HSTR_LEN); |
101 | i_lseek(mainfd, -HSTR_LEN, SEEK_END); |
102 | i_read(mainfd, &apple, HSTR_LEN); |
103 | count = apple.count; |
104 | |
105 | |
106 | printf ( "port:%d\n" , port); |
107 | printf ( "init successful!!!\n" ); |
108 | |
109 | return (0); |
110 | |
111 | } |
112 | /* end:initialize */ |
113 | /* start:chat_history*/ |
114 | int get_page_size() |
115 | { |
116 | struct chat_history page_size_reader; |
117 | |
118 | i_lseek(mainfd, -HSTR_LEN, SEEK_END); |
119 | i_read(mainfd, &page_size_reader, HSTR_LEN); |
120 | |
121 | return (page_size_reader.count); |
122 | } |
123 | |
124 | int read_chat_history() |
125 | { |
126 | printf ( "****char*history***" ); |
127 | printf ( "(n-nextpage; p-prepage; q-quit)\n" ); |
128 | |
129 | int page_num; /* */ |
130 | int remains; |
131 | int berry = get_page_size(); |
132 | |
133 | |
134 | page_num = berry / 8; |
135 | remains = berry % 8; |
136 | |
137 | if (remains != 0) |
138 | page_num ++; |
139 | else |
140 | page_num = page_num; |
141 | |
142 | printf ( "there are %d page total %d items" , |
143 | page_num, berry); |
144 | |
145 | int i = -1; |
146 | |
147 | while (1) |
148 | { |
149 | char flag; |
150 | |
151 | if ((berry + i*8) >= 0) |
152 | { |
153 | printf ( "(%d~%d)\n" , (berry + i*8), (berry + (i+1)*8)); |
154 | |
155 | i_print_history(PRT_LEN, i); |
156 | |
157 | printf ( "@@@\n" ); |
158 | while ( '\n' == (flag = getchar ())) |
159 | { |
160 | } |
161 | |
162 | switch (flag) |
163 | { |
164 | case 'p' : |
165 | i--; |
166 | break ; |
167 | case 'n' : |
168 | i++; |
169 | break ; |
170 | case 'q' : |
171 | return (0); |
172 | default : |
173 | break ; |
174 | } |
175 | if (i >= 0) |
176 | { |
177 | printf ( "have at the end!\n" ); |
178 | printf ( "return to menu!\n" ); |
179 | } |
180 | } |
181 | else |
182 | { |
183 | printf ( "(1~%d)\n" , remains); |
184 | |
185 | i_print_history(remains, 0); |
186 | |
187 | printf ( "#########over##############\n" ); |
188 | |
189 | return (0); |
190 | } |
191 | } |
192 | |
193 | return (0); |
194 | } |
195 | /* end:chat_history*/ |
196 | /* start:exit_sys*/ |
197 | void exit_sys() |
198 | { |
199 | close(sockfd); |
200 | close(mainfd); |
201 | kill(0, SIGABRT); |
202 | |
203 | exit (0); |
204 | } |
205 | /* end:exit_sys*/ |
206 | |
207 | /* start:menu*/ |
208 | int print_menu() |
209 | { |
210 | printf ( "\n--------------help--menu----------------\n" ); |
211 | printf ( "\t h--help munu\n" ); |
212 | printf ( "\t s--send message\n" ); |
213 | printf ( "\t r--reply to\n" ); |
214 | printf ( "\t c--chat history\n" ); |
215 | printf ( "\t f--send files\n" ); |
216 | printf ( "\t e--exit the system\n" ); |
217 | printf ( "----------------help--menu----------------\n" ); |
218 | } |
219 | int get_input( char *command) |
220 | { |
221 | printf ( ">" ); |
222 | scanf ( "%c" , command); |
223 | |
224 | return (1); |
225 | } |
226 | int menu() |
227 | { |
228 | /* to avoid the output at mixed with the sub process */ |
229 | sleep(1); |
230 | |
231 | print_menu(); |
232 | |
233 | char command; |
234 | |
235 | while (1 == get_input(&command)) |
236 | { |
237 | switch (command) |
238 | { |
239 | case 'h' : |
240 | print_menu(); |
241 | break ; |
242 | case 's' : |
243 | i_send_msg(); |
244 | break ; |
245 | case 'r' : |
246 | reply(); |
247 | break ; |
248 | case 'f' : |
249 | send_file(); |
250 | break ; |
251 | case 'c' : |
252 | read_chat_history(); |
253 | break ; |
254 | case 'e' : |
255 | exit_sys(); |
256 | break ; |
257 | default : |
258 | printf ( ">" ); |
259 | break ; |
260 | } |
261 | } |
262 | return (0); |
263 | } |
264 | /* end:menu*/ |
265 | /* start:message contol :send_msg and recv_msg */ |
266 | int ordnary_msg_recv( struct msg *pmsg) |
267 | { |
268 | char time_info[25]; |
269 | char end_symble; |
270 | end_symble = '&' ; |
271 | |
272 | /* handle the msg */ |
273 | printf ( "Message:from %s(id%d) to U:\n" , pmsg->append, pmsg->id_from); |
274 | i_print(pmsg->content, MSG_LEN); |
275 | printf ( "\n\t%s" , i_get_time()); |
276 | |
277 | return (0); |
278 | } |
279 | int file_msg_recv( struct msg *pmsg) |
280 | { |
281 | } |
282 | int handle_msg( struct msg *pmsg) |
283 | { |
284 | if (pmsg->flag == 1) |
285 | { |
286 | ordnary_msg_recv(pmsg); |
287 | return (0); |
288 | } |
289 | else if (pmsg->flag >= 4) |
290 | { |
291 | file_msg_recv(pmsg); |
292 | return (0); |
293 | } |
294 | return (0); |
295 | } |
296 | int listen_msg() |
297 | { |
298 | struct msg msg_recv; |
299 | struct sockaddr addr_recv; |
300 | int len = ADDR_LEN; |
301 | |
302 | printf ( "begin listen...\n" ); |
303 | |
304 | for ( ; ; ) |
305 | { |
306 | i_recvfrom(sockfd, &msg_recv, MSG_LEN, 0, |
307 | &addr_recv, &len); |
308 | |
309 | i_saveto_chat(&msg_recv); /* save to history */ |
310 | |
311 | ordnary_msg_recv(&msg_recv); |
312 | } |
313 | } |
314 | |
315 | /* end:message contol*/ |
316 | |
317 | /* start:log process :login and regist */ |
318 | int login() |
319 | { |
320 | /* input id:*/ |
321 | printf ( "*****login>>\n" ); |
322 | printf ( "id:" ); |
323 | scanf ( "%d" , &my_id); |
324 | /* input password*/ |
325 | char password[15]; |
326 | printf ( "\npassword(*less 15 char):" ); |
327 | scanf ( "%s" , password); |
328 | getchar (); |
329 | |
330 | /* send login information */ |
331 | struct msg log_msg; |
332 | |
333 | bzero(&log_msg, MSG_LEN); |
334 | log_msg.flag = 2; |
335 | log_msg.id_from = my_id; |
336 | log_msg.id_to = 0; |
337 | strncpy (log_msg.content, password, 15); |
338 | |
339 | i_saveto_chat(&log_msg); /* save to history */ |
340 | |
341 | i_sendto(sockfd, ( struct msg*)&log_msg, MSG_LEN, 0, |
342 | ( struct sockaddr*)&server, sizeof ( struct sockaddr)); |
343 | //printf("log_msg : %d\n", log_msg.id_from); |
344 | //printf("password: %s\n", log_msg.content); |
345 | /* after input msg ,wait for server respond*/ |
346 | struct sockaddr in_addr; |
347 | int len = ADDR_LEN; |
348 | i_recvfrom(sockfd, ( struct msg*)&log_msg, MSG_LEN,0, |
349 | &in_addr, &len); |
350 | if (2 == log_msg.flag) |
351 | { |
352 | printf ( "login success\n" ); |
353 | return (0); |
354 | } |
355 | else |
356 | { |
357 | printf ( "login error:%s\n" , log_msg.content); |
358 | printf ( "please relog..\n" ); |
359 | menu(); |
360 | } |
361 | |
362 | return (0); |
363 | } |
364 | int regist() |
365 | { |
366 | printf ( "*****regist>>\n" ); |
367 | /* input chat name */ |
368 | char name[10]; |
369 | |
370 | bzero(name, 10); |
371 | printf ( "input your chat name(less 8 char):" ); |
372 | scanf ( "%s" , name); |
373 | |
374 | //name[9] = ';'; /* add a ; symbol in the end of name */ |
375 | /* input password */ |
376 | char password[15]; |
377 | |
378 | bzero(password, 15); |
379 | printf ( "\ninput your password(less 14 char):" ); |
380 | scanf ( "%s" , password); |
381 | |
382 | /* send regist information*/ |
383 | struct msg reg_msg; |
384 | |
385 | bzero(®_msg, MSG_LEN); |
386 | reg_msg.flag = 3; |
387 | reg_msg.id_from = 0; |
388 | reg_msg.id_to = 0; |
389 | bzero(reg_msg.content, CNTNT_LEN); |
390 | strncpy (reg_msg.content, name, 10); |
391 | strncpy (&(reg_msg.content[10]), password, 15); |
392 | reg_msg.content[25] = '\n' ; |
393 | |
394 | i_saveto_chat(®_msg); /* save to history */ |
395 | |
396 | /* send regist informatin to server */ |
397 | i_sendto(sockfd, ( struct msg*)®_msg, sizeof ( struct msg), 0, |
398 | ( struct sockaddr*)&server, ADDR_LEN); |
399 | /* after input msg ,wait for server respond*/ |
400 | printf ( "wating for server reply...\n" ); |
401 | |
402 | struct sockaddr in_addr; |
403 | struct msg msg_back; |
404 | int len = ADDR_LEN; |
405 | |
406 | bzero(&in_addr, ADDR_LEN); |
407 | bzero(&msg_back, MSG_LEN); |
408 | i_recvfrom(sockfd,( struct msg*)&msg_back, MSG_LEN,0, |
409 | &in_addr, &len); |
410 | |
411 | /* check whether pass */ |
412 | if (3 != msg_back.flag) |
413 | { |
414 | printf ( "error: %s \n" , msg_back.content); |
415 | exit (1); |
416 | } |
417 | else |
418 | my_id = msg_back.id_to; |
419 | printf ( "congratulate! you have regist" |
420 | "id %s(id %d) success\n" , msg_back.content, msg_back.id_to); |
421 | |
422 | login(); |
423 | |
424 | return (0); |
425 | } |
426 | |
427 | int my_log() |
428 | { |
429 | /* choose login or regist*/ |
430 | char flag; |
431 | printf ( "are you want login or regist(l/r)\n" ); |
432 | scanf ( "%c" , &flag); |
433 | getchar (); |
434 | switch (flag){ |
435 | case 'l' : |
436 | login(); |
437 | break ; |
438 | case 'r' : |
439 | regist(); |
440 | break ; |
441 | default : |
442 | printf ( "error input\n" ); |
443 | my_log(); |
444 | break ; |
445 | } |
446 | return (0); |
447 | } |
448 | /* end:log */ |
449 | |
450 | int main() |
451 | { |
452 | init(); |
453 | printf ( "\n************welcome!************\n" ); |
454 | my_log(); |
455 | |
456 | pid_t pid; |
457 | |
458 | switch (pid = fork()) |
459 | { |
460 | case -1 : |
461 | perror ( "fork error!\n" ); |
462 | exit (1); |
463 | break ; |
464 | case 0 : |
465 | listen_msg(); |
466 | break ; |
467 | default : |
468 | menu(); |
469 | break ; |
470 | } |
471 | } |