2 * traffic-analyzer VFS module. Measure the smb traffic users create
5 * Copyright (C) Holger Hetterich, 2008
6 * Copyright (C) Jeremy Allison, 2008
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 /* abstraction for the send_over_network function */
25 enum sock_type
{INTERNET_SOCKET
= 0, UNIX_DOMAIN_SOCKET
};
27 #define LOCAL_PATHNAME "/var/tmp/stadsocket"
29 extern userdom_struct current_user_info
;
31 static int vfs_smb_traffic_analyzer_debug_level
= DBGC_VFS
;
33 static enum sock_type
smb_traffic_analyzer_connMode(vfs_handle_struct
*handle
)
35 connection_struct
*conn
= handle
->conn
;
37 Mode
=lp_parm_const_string(SNUM(conn
), "smb_traffic_analyzer","mode", \
39 if (strstr(Mode
,"unix_domain_socket")) {
40 return UNIX_DOMAIN_SOCKET
;
42 return INTERNET_SOCKET
;
46 /* Connect to an internet socket */
48 static int smb_traffic_analyzer_connect_inet_socket(vfs_handle_struct
*handle
,
49 const char *name
, uint16_t port
)
51 /* Create a streaming Socket */
53 struct addrinfo hints
;
54 struct addrinfo
*ailist
= NULL
;
55 struct addrinfo
*res
= NULL
;
59 /* By default make sure it supports TCP. */
60 hints
.ai_socktype
= SOCK_STREAM
;
61 hints
.ai_flags
= AI_ADDRCONFIG
;
63 ret
= getaddrinfo(name
,
69 DEBUG(3,("smb_traffic_analyzer_connect_inet_socket: "
70 "getaddrinfo failed for name %s [%s]\n",
76 DEBUG(3,("smb_traffic_analyzer: Internet socket mode. Hostname: %s,"
77 "Port: %i\n", name
, port
));
79 for (res
= ailist
; res
; res
= res
->ai_next
) {
80 struct sockaddr_storage ss
;
82 if (!res
->ai_addr
|| res
->ai_addrlen
== 0) {
87 memcpy(&ss
, res
->ai_addr
, res
->ai_addrlen
);
89 sockfd
= open_socket_out(SOCK_STREAM
, &ss
, port
, 10000);
100 DEBUG(1, ("smb_traffic_analyzer: unable to create "
101 "socket, error is %s",
109 /* Connect to a unix domain socket */
111 static int smb_traffic_analyzer_connect_unix_socket(vfs_handle_struct
*handle
,
114 /* Create the socket to stad */
116 struct sockaddr_un remote
;
118 DEBUG(7, ("smb_traffic_analyzer_connect_unix_socket: "
119 "Unix domain socket mode. Using %s\n",
122 if ((sock
= socket(AF_UNIX
, SOCK_STREAM
, 0)) == -1) {
123 DEBUG(1, ("smb_traffic_analyzer_connect_unix_socket: "
124 "Couldn't create socket, "
125 "make sure stad is running!\n"));
127 remote
.sun_family
= AF_UNIX
;
128 strlcpy(remote
.sun_path
, name
,
129 sizeof(remote
.sun_path
));
130 len
=strlen(remote
.sun_path
) + sizeof(remote
.sun_family
);
131 if (connect(sock
, (struct sockaddr
*)&remote
, len
) == -1 ) {
132 DEBUG(1, ("smb_traffic_analyzer_connect_unix_socket: "
133 "Could not connect to "
134 "socket, make sure\nstad is running!\n"));
141 /* Private data allowing shared connection sockets. */
143 struct refcounted_sock
{
144 struct refcounted_sock
*next
, *prev
;
148 unsigned int ref_count
;
151 /* Send data over a socket */
153 static void smb_traffic_analyzer_send_data(vfs_handle_struct
*handle
,
155 const char *file_name
,
158 struct refcounted_sock
*rf_sock
= NULL
;
161 struct tm
*tm
= NULL
;
166 SMB_VFS_HANDLE_GET_DATA(handle
, rf_sock
, struct refcounted_sock
, return);
168 if (rf_sock
== NULL
|| rf_sock
->sock
== -1) {
169 DEBUG(1, ("smb_traffic_analyzer_send_data: socket is "
175 tv_sec
= convert_timespec_to_time_t(convert_timeval_to_timespec(tv
));
176 tm
= localtime(&tv_sec
);
180 seconds
=(float) (tv
.tv_usec
/ 1000);
182 str
= talloc_asprintf(talloc_tos(),
183 "V1,%u,\"%s\",\"%s\",\"%c\",\"%s\",\"%s\","
184 "\"%04d-%02d-%02d %02d:%02d:%02d.%03d\"\n",
185 (unsigned int)result
,
186 get_current_username(),
187 current_user_info
.domain
,
189 handle
->conn
->connectpath
,
205 DEBUG(10, ("smb_traffic_analyzer_send_data_socket: sending %s\n",
207 if (write_data(rf_sock
->sock
, str
, len
) != len
) {
208 DEBUG(1, ("smb_traffic_analyzer_send_data_socket: "
209 "error sending data to socket!\n"));
214 static struct refcounted_sock
*sock_list
;
216 static void smb_traffic_analyzer_free_data(void **pptr
)
218 struct refcounted_sock
*rf_sock
= *(struct refcounted_sock
**)pptr
;
219 if (rf_sock
== NULL
) {
222 rf_sock
->ref_count
--;
223 if (rf_sock
->ref_count
!= 0) {
226 if (rf_sock
->sock
!= -1) {
227 close(rf_sock
->sock
);
229 DLIST_REMOVE(sock_list
, rf_sock
);
230 TALLOC_FREE(rf_sock
);
233 static int smb_traffic_analyzer_connect(struct vfs_handle_struct
*handle
,
237 connection_struct
*conn
= handle
->conn
;
238 enum sock_type st
= smb_traffic_analyzer_connMode(handle
);
239 struct refcounted_sock
*rf_sock
= NULL
;
240 const char *name
= (st
== UNIX_DOMAIN_SOCKET
) ? LOCAL_PATHNAME
:
241 lp_parm_const_string(SNUM(conn
),
242 "smb_traffic_analyzer",
243 "host", "localhost");
244 uint16_t port
= (st
== UNIX_DOMAIN_SOCKET
) ? 0 :
245 atoi( lp_parm_const_string(SNUM(conn
),
246 "smb_traffic_analyzer", "port", "9430"));
248 /* Are we already connected ? */
249 for (rf_sock
= sock_list
; rf_sock
; rf_sock
= rf_sock
->next
) {
250 if (port
== rf_sock
->port
&&
251 (strcmp(name
, rf_sock
->name
) == 0)) {
256 /* If we're connected already, just increase the
257 * reference count. */
259 rf_sock
->ref_count
++;
261 /* New connection. */
262 rf_sock
= TALLOC_ZERO_P(NULL
, struct refcounted_sock
);
263 if (rf_sock
== NULL
) {
267 rf_sock
->name
= talloc_strdup(rf_sock
, name
);
268 if (rf_sock
->name
== NULL
) {
269 TALLOC_FREE(rf_sock
);
273 rf_sock
->port
= port
;
274 rf_sock
->ref_count
= 1;
276 if (st
== UNIX_DOMAIN_SOCKET
) {
277 rf_sock
->sock
= smb_traffic_analyzer_connect_unix_socket(handle
,
281 rf_sock
->sock
= smb_traffic_analyzer_connect_inet_socket(handle
,
285 if (rf_sock
->sock
== -1) {
286 TALLOC_FREE(rf_sock
);
289 DLIST_ADD(sock_list
, rf_sock
);
292 /* Store the private data. */
293 SMB_VFS_HANDLE_SET_DATA(handle
, rf_sock
, smb_traffic_analyzer_free_data
,
294 struct refcounted_sock
, return -1);
295 return SMB_VFS_NEXT_CONNECT(handle
, service
, user
);
298 /* VFS Functions: write, read, pread, pwrite for now */
300 static ssize_t
smb_traffic_analyzer_read(vfs_handle_struct
*handle
, \
301 files_struct
*fsp
, void *data
, size_t n
)
305 result
= SMB_VFS_NEXT_READ(handle
, fsp
, data
, n
);
306 DEBUG(10, ("smb_traffic_analyzer_read: READ: %s\n", fsp
->fsp_name
));
308 smb_traffic_analyzer_send_data(handle
,
316 static ssize_t
smb_traffic_analyzer_pread(vfs_handle_struct
*handle
, \
317 files_struct
*fsp
, void *data
, size_t n
, SMB_OFF_T offset
)
321 result
= SMB_VFS_NEXT_PREAD(handle
, fsp
, data
, n
, offset
);
323 DEBUG(10, ("smb_traffic_analyzer_pread: PREAD: %s\n", fsp
->fsp_name
));
325 smb_traffic_analyzer_send_data(handle
,
333 static ssize_t
smb_traffic_analyzer_write(vfs_handle_struct
*handle
, \
334 files_struct
*fsp
, const void *data
, size_t n
)
338 result
= SMB_VFS_NEXT_WRITE(handle
, fsp
, data
, n
);
340 DEBUG(10, ("smb_traffic_analyzer_write: WRITE: %s\n", fsp
->fsp_name
));
342 smb_traffic_analyzer_send_data(handle
,
349 static ssize_t
smb_traffic_analyzer_pwrite(vfs_handle_struct
*handle
, \
350 files_struct
*fsp
, const void *data
, size_t n
, SMB_OFF_T offset
)
354 result
= SMB_VFS_NEXT_PWRITE(handle
, fsp
, data
, n
, offset
);
356 DEBUG(10, ("smb_traffic_analyzer_pwrite: PWRITE: %s\n", fsp
->fsp_name
));
358 smb_traffic_analyzer_send_data(handle
,
365 /* VFS operations we use */
367 static vfs_op_tuple smb_traffic_analyzer_tuples
[] = {
369 {SMB_VFS_OP(smb_traffic_analyzer_connect
), SMB_VFS_OP_CONNECT
,
370 SMB_VFS_LAYER_LOGGER
},
371 {SMB_VFS_OP(smb_traffic_analyzer_read
), SMB_VFS_OP_READ
,
372 SMB_VFS_LAYER_LOGGER
},
373 {SMB_VFS_OP(smb_traffic_analyzer_pread
), SMB_VFS_OP_PREAD
,
374 SMB_VFS_LAYER_LOGGER
},
375 {SMB_VFS_OP(smb_traffic_analyzer_write
), SMB_VFS_OP_WRITE
,
376 SMB_VFS_LAYER_LOGGER
},
377 {SMB_VFS_OP(smb_traffic_analyzer_pwrite
), SMB_VFS_OP_PWRITE
,
378 SMB_VFS_LAYER_LOGGER
},
379 {SMB_VFS_OP(NULL
),SMB_VFS_OP_NOOP
,SMB_VFS_LAYER_NOOP
}
382 /* Module initialization */
384 NTSTATUS
vfs_smb_traffic_analyzer_init(void)
386 NTSTATUS ret
= smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, \
387 "smb_traffic_analyzer", smb_traffic_analyzer_tuples
);
389 if (!NT_STATUS_IS_OK(ret
)) {
393 vfs_smb_traffic_analyzer_debug_level
=
394 debug_add_class("smb_traffic_analyzer");
396 if (vfs_smb_traffic_analyzer_debug_level
== -1) {
397 vfs_smb_traffic_analyzer_debug_level
= DBGC_VFS
;
398 DEBUG(1, ("smb_traffic_analyzer_init: Couldn't register custom"
399 "debugging class!\n"));
401 DEBUG(3, ("smb_traffic_analyzer_init: Debug class number of"
402 "'smb_traffic_analyzer': %d\n", \
403 vfs_smb_traffic_analyzer_debug_level
));