2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Copyright (C) Rafal Szczesniak 2002
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 * @brief This is part of the net tool which is basically command
26 * line wrapper for gencache.c functions (mainly for testing)
32 * These routines are used via gencache_iterate() to display the cache's contents
33 * (print_cache_entry) and to flush it (delete_cache_entry).
34 * Both of them are defined by first arg of gencache_iterate() routine.
36 static void print_cache_entry(const char* keystr
, const char* datastr
,
37 const time_t timeout
, void* dptr
)
40 char *alloc_str
= NULL
;
41 time_t now_t
= time(NULL
);
42 struct tm timeout_tm
, *now_tm
;
43 /* localtime returns statically allocated pointer, so timeout_tm
44 has to be copied somewhere else */
46 now_tm
= localtime(&timeout
);
50 memcpy(&timeout_tm
, now_tm
, sizeof(struct tm
));
51 now_tm
= localtime(&now_t
);
56 /* form up timeout string depending whether it's today's date or not */
57 if (timeout_tm
.tm_year
!= now_tm
->tm_year
||
58 timeout_tm
.tm_mon
!= now_tm
->tm_mon
||
59 timeout_tm
.tm_mday
!= now_tm
->tm_mday
) {
61 timeout_str
= asctime(&timeout_tm
);
65 timeout_str
[strlen(timeout_str
) - 1] = '\0'; /* remove tailing CR */
67 if (asprintf(&alloc_str
, "%.2d:%.2d:%.2d", timeout_tm
.tm_hour
,
68 timeout_tm
.tm_min
, timeout_tm
.tm_sec
) == -1) {
71 timeout_str
= alloc_str
;
74 d_printf("Key: %s\t Timeout: %s\t Value: %s %s\n", keystr
,
75 timeout_str
, datastr
, timeout
> now_t
? "": "(expired)");
80 static void delete_cache_entry(const char* keystr
, const char* datastr
,
81 const time_t timeout
, void* dptr
)
83 if (!gencache_del(keystr
))
84 d_fprintf(stderr
, "Couldn't delete entry! key = %s\n", keystr
);
89 * Parse text representation of timeout value
91 * @param timeout_str string containing text representation of the timeout
92 * @return numeric timeout of time_t type
94 static time_t parse_timeout(const char* timeout_str
)
96 char sign
= '\0', *number
= NULL
, unit
= '\0';
97 int len
, number_begin
, number_end
;
101 if (timeout_str
[0] == '!' || timeout_str
[0] == '+') {
102 sign
= timeout_str
[0];
109 len
= strlen(timeout_str
);
110 switch (timeout_str
[len
- 1]) {
115 case 'w': unit
= timeout_str
[len
- 1];
118 /* number detection */
119 len
= (sign
) ? strlen(&timeout_str
[number_begin
]) : len
;
120 number_end
= (unit
) ? len
- 1 : len
;
121 number
= SMB_STRNDUP(&timeout_str
[number_begin
], number_end
);
123 /* calculate actual timeout value */
124 timeout
= (time_t)atoi(number
);
127 case 'm': timeout
*= 60; break;
128 case 'h': timeout
*= 60*60; break;
129 case 'd': timeout
*= 60*60*24; break;
130 case 'w': timeout
*= 60*60*24*7; break; /* that's fair enough, I think :) */
134 case '!': timeout
= time(NULL
) - timeout
; break;
136 default: timeout
+= time(NULL
); break;
139 if (number
) SAFE_FREE(number
);
145 * Add an entry to the cache. If it does exist, then set it.
147 * @param c A net_context structure
148 * @param argv key, value and timeout are passed in command line
149 * @return 0 on success, otherwise failure
151 static int net_cache_add(struct net_context
*c
, int argc
, const char **argv
)
153 const char *keystr
, *datastr
, *timeout_str
;
156 if (argc
< 3 || c
->display_usage
) {
157 d_printf("\nUsage: net cache add <key string> <data string> <timeout>\n");
163 timeout_str
= argv
[2];
165 /* parse timeout given in command line */
166 timeout
= parse_timeout(timeout_str
);
168 d_fprintf(stderr
, "Invalid timeout argument.\n");
172 if (gencache_set(keystr
, datastr
, timeout
)) {
173 d_printf("New cache entry stored successfully.\n");
178 d_fprintf(stderr
, "Entry couldn't be added. Perhaps there's already such a key.\n");
184 * Delete an entry in the cache
186 * @param c A net_context structure
187 * @param argv key to delete an entry of
188 * @return 0 on success, otherwise failure
190 static int net_cache_del(struct net_context
*c
, int argc
, const char **argv
)
192 const char *keystr
= argv
[0];
194 if (argc
< 1 || c
->display_usage
) {
195 d_printf("\nUsage: net cache del <key string>\n");
199 if(gencache_del(keystr
)) {
200 d_printf("Entry deleted.\n");
204 d_fprintf(stderr
, "Couldn't delete specified entry\n");
210 * Get and display an entry from the cache
212 * @param c A net_context structure
213 * @param argv key to search an entry of
214 * @return 0 on success, otherwise failure
216 static int net_cache_get(struct net_context
*c
, int argc
, const char **argv
)
218 const char* keystr
= argv
[0];
222 if (argc
< 1 || c
->display_usage
) {
223 d_printf("\nUsage: net cache get <key>\n");
227 if (gencache_get(keystr
, &valuestr
, &timeout
)) {
228 print_cache_entry(keystr
, valuestr
, timeout
, NULL
);
232 d_fprintf(stderr
, "Failed to find entry\n");
238 * Search an entry/entries in the cache
240 * @param c A net_context structure
241 * @param argv key pattern to match the entries to
242 * @return 0 on success, otherwise failure
244 static int net_cache_search(struct net_context
*c
, int argc
, const char **argv
)
248 if (argc
< 1 || c
->display_usage
) {
249 d_printf("Usage: net cache search <pattern>\n");
254 gencache_iterate(print_cache_entry
, NULL
, pattern
);
260 * List the contents of the cache
262 * @param c A net_context structure
263 * @param argv ignored in this functionailty
264 * @return always returns 0
266 static int net_cache_list(struct net_context
*c
, int argc
, const char **argv
)
268 const char* pattern
= "*";
270 if (c
->display_usage
) {
273 " List all cache entries.\n");
276 gencache_iterate(print_cache_entry
, NULL
, pattern
);
283 * Flush the whole cache
285 * @param c A net_context structure
286 * @param argv ignored in this functionality
287 * @return always returns 0
289 static int net_cache_flush(struct net_context
*c
, int argc
, const char **argv
)
291 const char* pattern
= "*";
292 if (c
->display_usage
) {
295 " Delete all cache entries.\n");
298 gencache_iterate(delete_cache_entry
, NULL
, pattern
);
304 * Entry point to 'net cache' subfunctionality
306 * @param c A net_context structure
307 * @param argv arguments passed to further called functions
308 * @return whatever further functions return
310 int net_cache(struct net_context
*c
, int argc
, const char **argv
)
312 struct functable func
[] = {
317 "Add new cache entry",
318 "net cache add <key string> <data string> <timeout>\n"
319 " Add new cache entry.\n"
320 " key string\tKey string to add cache data under.\n"
321 " data string\tData to store under given key.\n"
322 " timeout\tTimeout for cache data."
328 "Delete existing cache entry by key",
329 "net cache del <key string>\n"
330 " Delete existing cache entry by key.\n"
331 " key string\tKey string to delete."
337 "Get cache entry by key",
338 "net cache get <key string>\n"
339 " Get cache entry by key.\n"
340 " key string\tKey string to look up cache entry for."
347 "Search entry by pattern",
348 "net cache search <pattern>\n"
349 " Search entry by pattern.\n"
350 " pattern\tPattern to search for in cache."
356 "List all cache entries",
358 " List all cache entries"
364 "Delete all cache entries",
366 " Delete all cache entries"
368 {NULL
, NULL
, 0, NULL
, NULL
}
371 return net_run_function(c
, argc
, argv
, "net cache", func
);