Clamav AntiVirus software source code analysis notes [7]

Clamav AntiVirus software source code analysis notes [7]

Hedgehog @ http://blog.csdn.net/littlehedgehog

[Accept loop processing]

I could have finished the main Clamd functions in Article 5 last time, but the thread is not running and the fire is not yet reached. The end of Clamd will be reached.

1. If (thr_pool = thrmgr_new (max_threads, idletimeout, scanner_thread) = NULL)
2. {
3. Logg ("! Thrmgr_new failed/n ");
4. Exit (-1 );
5. }
7. Time (& start_time); // record current time saved in start_time
9. For (;;)
10. {
11. New_sd = accept (socketd, NULL, NULL );
13. /* Note that the interrupt will interrupt accept blocking. Here we only need to check whether errno is EINTR. If the returned value is-1 (indicating accpet failure)
14. * This is not due to interruption, but to other problems.
15. */
16. If (new_sd =-1) & (errno! = EINTR ))
17. {
18. /* Very bad-need to exit or restart */
19. # Ifdef HAVE_STRERROR_R
20. Logg ("! Accept () failed: % s/n ", strerror_r (errno, buff, BUFFSIZE ));
21. # Else
22. Logg ("! Accept () failed/n ");
23. # Endif
24. Continue;
25. }
27. /* This signal indicates that the terminal is disconnected. We need to re-open the log file */
28. If (sighup)
29. {
30. Logg ("sighup caught: re-opening log file./N ");
31. Logg_close ();
32. Sighup = 0;
33. If (! Logg_file & (CPT = partition OPT (COPT, "logfile ")))
34. Logg_file = CPT-> strarg;
35. }
37. /* Progexit is the identifier that our process receives the SIGINT-Related Signal settings. If it is unfortunate that it is received, we will exit */
38. If (! Progexit & new_sd> = 0)
39. {
40. Client_conn = (client_conn_t *) mmalloc (sizeof (struct client_conn_tag); // here is the userdata parameter for assembling thrmgr_dispatch
41. Client_conn-> sd = new_sd; // socket descriptor! This is always used later as a channel for communications between the server and the client.
42. Client_conn-> options = options;
43. Client_conn-> copt = copt;
44. Client_conn-> root = cl_dup (root );
45. Client_conn-> root_timestamp = reloaded_time;
46. Client_conn-> limits = & limits;
47. Client_conn-> mainpid = mainpid;
48. If (! Thrmgr_dispatch (thr_pool, client_conn ))
49. {
50. Close (client_conn-> SD );
51. Free (client_conn );
52. Logg ("! Thread dispatch failed/N ");
53. }
54. }
56. Pthread_mutex_lock (& exit_mutex );
57. If (progexit)
58. {
59. If (new_sd> = 0)
60. {
61. Close (new_sd );
62. }
63. Pthread_mutex_unlock (& exit_mutex );
64. Break;
65. }
66. Pthread_mutex_unlock (& exit_mutex );
68. // If self-check is set
69. If (selfchk)
70. {
71. Time (& current_time );
72. If (current_time-start_time)> (time_t) selfchk) // This indicates that the time of the virus database exceeds the effective time set by us.
73. {
74. If (reload_db (root, copt, TRUE) // check whether the database has been changed. if you want to set reload, reload the following nodes.
75. {
76. Pthread_mutex_lock (& reload_mutex );
77. Reload = 1;
78. Pthread_mutex_unlock (& reload_mutex );
79. }
80. Time (& start_time );
81. }
82. }
84. Pthread_mutex_lock (& reload_mutex );
85. If (reload)
86. {
87. Pthread_mutex_unlock (& reload_mutex );
88. Root = reload_db (root, COPT, false );
89. Pthread_mutex_lock (& reload_mutex );
90. Reload = 0;
91. Time (& reloaded_time );
92. Pthread_mutex_unlock (& reload_mutex );
93. # Ifdef clamuko
94. If (export OPT (COPT, "clamukoscanonline") | export OPT (COPT, "clamukoscanonaccess "))
95. {
96. Logg ("Stopping and restarting Clamuko./n ");
97. Pthread_kill (clamuko_pid, SIGUSR1 );
98. Pthread_join (clamuko_pid, NULL );
99. Tharg-> root = root;
100. Pthread_create (& clamuko_pid, & clamuko_attr, clamukoth, tharg );
101. }
102. # Endif
103. }
104. Else
105. {
106. Pthread_mutex_unlock (& reload_mutex );
107. }
108. }
110. /* Destroy the thread manager.
111. * This waits for all current tasks to end
112. */
113. Thrmgr_destroy (thr_pool );

Post it here If (thr_pool = thrmgr_new (max_threads, idletimeout, scanner_thread) = NULL)

The main reason is that when we create a thread pool, we have determined the function to be executed by the thread.Scanner_threadYou can look back at the thread pool creation and processing code. The following is to assemble the parameter struct for the thread. The main reason is that the parameter passing form of the thread has been fixed, so we need to load the struct.

The processing function of the thread is only a proxy. The cadres who really do things only have command, as shown below:

1. /* Set the main function of the thread to process the job */
2. Void scanner_thread (void * Arg)
3. {
4. Client_conn_t * conn = (client_conn_t *) ARG;
5. Sigset_t sigset;
6. Int ret, timeout, session = false;
7. Struct explain struct * CPT;
10. /* Ignore all signals the author has already commented on it. Here it is set to 1, which is actually a blocked signal */
11. Sigfillset (& sigset );
12. Pthread_sigmask (sig_setmask, & sigset, null); // sets the thread signal shielding code. The semantics is the same as sigprocmask, however, cancel signals that cannot be blocked and restart signals that cannot be responded are protected. Blocked signals are stored in the signal queue and can be taken out by the sigpending () function.
14. If (CPT = fig (Conn-> COPT, "readtimeout ")))
15. {
16. Timeout = cpt-> numarg;
17. }
18. Else
19. {
20. Timeout = CL_DEFAULT_SCANTIMEOUT;
21. }
23. If (! Timeout)
24. Timeout =-1;
26. Do
27. {
28. Ret = command (conn-> sd, conn-> root, conn-> limits, conn-> options, conn-> copt, timeout); // This is the real Officer
29. If (ret =-1)
30. {
31. Break;
32. }
34. Switch (ret)
35. {
36. Case COMMAND_SHUTDOWN:
37. Pthread_mutex_lock (& exit_mutex );
38. Progexit = 1;
39. Kill (conn-> mainpid, SIGTERM); // here, the Shutdown signal is sent to the main thread, that is, the server process.
40. Pthread_mutex_unlock (& exit_mutex );
41. Break;
43. Case COMMAND_RELOAD:
44. Pthread_mutex_lock (& reload_mutex );
45. Reload = 1;
46. Pthread_mutex_unlock (& reload_mutex );
47. Break;
49. Case COMMAND_SESSION: // the client sends the command session. We still need to continue to obtain the command loop here (but in what status do we need to send this command)
50. Session = TRUE;
51. Timeout = 5;
52. Break;
54. Case COMMAND_END:
55. Session = FALSE;
56. Break;
57. }
58. If (session)
59. {
60. Pthread_mutex_lock (& exit_mutex );
61. If (progexit)
62. {
63. Session = FALSE;
64. }
65. Pthread_mutex_unlock (& exit_mutex );
66. Pthread_mutex_lock (& reload_mutex );
67. If (Conn-> root_timestamp! = Reloaded_time)
68. {
69. Session = false;
70. }
71. Pthread_mutex_unlock (& reload_mutex );
72. }
73. }
74. While (session );
76. Close (Conn-> SD );
77. Cl_free (Conn-> root );
78. Free (conn );
79. Return;
80. }

In this way, through command, we shirk the task to other functions to do it. command is the final function, but it will wait for the next time, because the lab is about to close.