source: trunk/server/source3/client/tree.c@ 971

Last change on this file since 971 was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 21.5 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 SMB client GTK+ tree-based application
4 Copyright (C) Andrew Tridgell 1998
5 Copyright (C) Richard Sharpe 2001
6 Copyright (C) John Terpstra 2001
7
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.
12
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.
17
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/>.
20*/
21
22/* example-gtk+ application, ripped off from the gtk+ tree.c sample */
23
24#include <stdio.h>
25#include <errno.h>
26#include <gtk/gtk.h>
27#include "libsmbclient.h"
28
29static GtkWidget *clist;
30
31struct tree_data {
32
33 guint32 type; /* Type of tree item, an SMBC_TYPE */
34 char name[256]; /* May need to change this later */
35
36};
37
38static void tree_error_message(gchar *message) {
39
40 GtkWidget *dialog, *label, *okay_button;
41
42 /* Create the widgets */
43
44 dialog = gtk_dialog_new();
45 gtk_window_set_modal(GTK_WINDOW(dialog), True);
46 label = gtk_label_new (message);
47 okay_button = gtk_button_new_with_label("Okay");
48
49 /* Ensure that the dialog box is destroyed when the user clicks ok. */
50
51 gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
52 GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog);
53 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
54 okay_button);
55
56 /* Add the label, and show everything we've added to the dialog. */
57
58 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
59 label);
60 gtk_widget_show_all (dialog);
61}
62
63/*
64 * We are given a widget, and we want to retrieve its URL so we
65 * can do a directory listing.
66 *
67 * We walk back up the tree, picking up pieces until we hit a server or
68 * workgroup type and return a path from there
69 */
70
71static char *path_string;
72
73char *get_path(TALLOC_CTX *ctx, GtkWidget *item)
74{
75 GtkWidget *p = item;
76 struct tree_data *pd;
77 char *comps[1024]; /* We keep pointers to the components here */
78 int i = 0, j, level,type;
79
80 /* Walk back up the tree, getting the private data */
81
82 level = GTK_TREE(item->parent)->level;
83
84 /* Pick up this item's component info */
85
86 pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item));
87
88 comps[i++] = pd->name;
89 type = pd->type;
90
91 while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) {
92
93 /* Find the parent and extract the data etc ... */
94
95 p = GTK_WIDGET(p->parent);
96 p = GTK_WIDGET(GTK_TREE(p)->tree_owner);
97
98 pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p));
99
100 level = GTK_TREE(item->parent)->level;
101
102 comps[i++] = pd->name;
103 type = pd->type;
104
105 }
106
107 /*
108 * Got a list of comps now, should check that we did not hit a workgroup
109 * when we got other things as well ... Later
110 *
111 * Now, build the path
112 */
113
114 TALLOC_FREE(path_string);
115 path_string = talloc_strdup(ctx, "smb:/");
116
117 if (path_string) {
118 for (j = i - 1; j >= 0; j--) {
119 path_string = talloc_asprintf_append(path_string, "/%s", comps[j]);
120 }
121 }
122
123 if (path_string) {
124 fprintf(stdout, "Path string = %s\n", path_string);
125 }
126
127 return path_string;
128
129}
130
131struct tree_data *make_tree_data(guint32 type, const char *name)
132{
133 struct tree_data *p = SMB_MALLOC_P(struct tree_data);
134
135 if (p) {
136
137 p->type = type;
138 strncpy(p->name, name, sizeof(p->name));
139
140 }
141
142 return p;
143
144}
145
146/* Note that this is called every time the user clicks on an item,
147 whether it is already selected or not. */
148static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
149 GtkWidget *subtree)
150{
151 gint dh, err, dirlen;
152 char dirbuf[512];
153 struct smbc_dirent *dirp;
154 struct stat st1;
155 char *path;
156 TALLOC_CTX *ctx = talloc_stackframe();
157
158 g_print ("select_child called for root tree %p, subtree %p, child %p\n",
159 root_tree, subtree, child);
160
161 /* Now, figure out what it is, and display it in the clist ... */
162
163 gtk_clist_clear(GTK_CLIST(clist)); /* Clear the CLIST */
164
165 /* Now, get the private data for the subtree */
166
167 path = get_path(ctx, child);
168 if (!path) {
169 gtk_main_quit();
170 TALLOC_FREE(ctx);
171 return;
172 }
173
174 if ((dh = smbc_opendir(path)) < 0) { /* Handle error */
175 g_print("cb_select_child: Could not open dir %s, %s\n", path,
176 strerror(errno));
177 gtk_main_quit();
178 TALLOC_FREE(ctx);
179 return;
180 }
181
182 while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
183 sizeof(dirbuf))) != 0) {
184 if (err < 0) {
185 g_print("cb_select_child: Could not read dir %s, %s\n", path,
186 strerror(errno));
187 gtk_main_quit();
188 TALLOC_FREE(ctx);
189 return;
190 }
191
192 dirp = (struct smbc_dirent *)dirbuf;
193
194 while (err > 0) {
195 gchar col1[128], col2[128], col3[128], col4[128];
196 gchar *rowdata[4] = {col1, col2, col3, col4};
197
198 dirlen = dirp->dirlen;
199
200 /* Format each of the items ... */
201
202 strncpy(col1, dirp->name, 128);
203
204 col2[0] = col3[0] = col4[0] = (char)0;
205
206 switch (dirp->smbc_type) {
207
208 case SMBC_WORKGROUP:
209
210 break;
211
212 case SMBC_SERVER:
213
214 strncpy(col2, (dirp->comment?dirp->comment:""), 128);
215
216 break;
217
218 case SMBC_FILE_SHARE:
219
220 strncpy(col2, (dirp->comment?dirp->comment:""), 128);
221
222 break;
223
224 case SMBC_PRINTER_SHARE:
225
226 strncpy(col2, (dirp->comment?dirp->comment:""), 128);
227 break;
228
229 case SMBC_COMMS_SHARE:
230
231 break;
232
233 case SMBC_IPC_SHARE:
234
235 break;
236
237 case SMBC_DIR:
238 case SMBC_FILE:
239
240 /* Get stats on the file/dir and see what we have */
241
242 if ((strcmp(dirp->name, ".") != 0) &&
243 (strcmp(dirp->name, "..") != 0)) {
244 char *path1;
245
246 path1 = talloc_asprintf(ctx,
247 "%s/%s",
248 path,
249 dirp->name);
250 if (!path1) {
251 gtk_main_quit();
252 TALLOC_FREE(ctx);
253 return;
254 }
255
256 if (smbc_stat(path1, &st1) < 0) {
257 if (errno != EBUSY) {
258 g_print("cb_select_child: Could not stat file %s, %s\n", path1,
259 strerror(errno));
260 gtk_main_quit();
261 TALLOC_FREE(ctx);
262 return;
263 } else {
264 strncpy(col2, "Device or resource busy", sizeof(col2));
265 }
266 }
267 else {
268 /* Now format each of the relevant things ... */
269
270 snprintf(col2, sizeof(col2), "%c%c%c%c%c%c%c%c%c(%0X)",
271 (st1.st_mode&S_IRUSR?'r':'-'),
272 (st1.st_mode&S_IWUSR?'w':'-'),
273 (st1.st_mode&S_IXUSR?'x':'-'),
274 (st1.st_mode&S_IRGRP?'r':'-'),
275 (st1.st_mode&S_IWGRP?'w':'-'),
276 (st1.st_mode&S_IXGRP?'x':'-'),
277 (st1.st_mode&S_IROTH?'r':'-'),
278 (st1.st_mode&S_IWOTH?'w':'-'),
279 (st1.st_mode&S_IXOTH?'x':'-'),
280 st1.st_mode);
281 snprintf(col3, sizeof(col3), "%u", st1.st_size);
282 snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_mtime));
283 }
284 }
285
286 break;
287
288 default:
289
290 break;
291 }
292
293 gtk_clist_append(GTK_CLIST(clist), rowdata);
294
295 (char *)dirp += dirlen;
296 err -= dirlen;
297
298 }
299 }
300 TALLOC_FREE(ctx);
301}
302
303/* Note that this is never called */
304static void cb_unselect_child( GtkWidget *root_tree,
305 GtkWidget *child,
306 GtkWidget *subtree )
307{
308 g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
309 root_tree, subtree, child);
310}
311
312/* for all the GtkItem:: and GtkTreeItem:: signals */
313static void cb_itemsignal( GtkWidget *item,
314 gchar *signame )
315{
316 GtkWidget *real_tree, *aitem, *subtree;
317 gchar *name;
318 GtkLabel *label;
319 gint dh, err, dirlen, level;
320 char dirbuf[512];
321 struct smbc_dirent *dirp;
322
323 label = GTK_LABEL (GTK_BIN (item)->child);
324 /* Get the text of the label */
325 gtk_label_get (label, &name);
326
327 level = GTK_TREE(item->parent)->level;
328
329 /* Get the level of the tree which the item is in */
330 g_print ("%s called for item %s->%p, level %d\n", signame, name,
331 item, GTK_TREE (item->parent)->level);
332
333 real_tree = GTK_TREE_ITEM_SUBTREE(item); /* Get the subtree */
334
335 if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
336 char server[128];
337
338 if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */
339 gchar errmsg[256];
340
341 g_print("cb_itemsignal: Could not open dir %s, %s\n", get_path(item),
342 strerror(errno));
343
344 slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not open dir %s, %s\n", get_path(item), strerror(errno));
345
346 tree_error_message(errmsg);
347
348 /* gtk_main_quit();*/
349
350 return;
351
352 }
353
354 while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
355 sizeof(dirbuf))) != 0) {
356
357 if (err < 0) { /* An error, report it */
358 gchar errmsg[256];
359
360 g_print("cb_itemsignal: Could not read dir smbc://, %s\n",
361 strerror(errno));
362
363 slprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not read dir smbc://, %s\n", strerror(errno));
364
365 tree_error_message(errmsg);
366
367 /* gtk_main_quit();*/
368
369 return;
370
371 }
372
373 dirp = (struct smbc_dirent *)dirbuf;
374
375 while (err > 0) {
376 struct tree_data *my_data;
377
378 dirlen = dirp->dirlen;
379
380 my_data = make_tree_data(dirp->smbc_type, dirp->name);
381
382 if (!my_data) {
383
384 g_print("Could not allocate space for tree_data: %s\n",
385 dirp->name);
386
387 gtk_main_quit();
388 return;
389
390 }
391
392 aitem = gtk_tree_item_new_with_label(dirp->name);
393
394 /* Connect all GtkItem:: and GtkTreeItem:: signals */
395 gtk_signal_connect (GTK_OBJECT(aitem), "select",
396 GTK_SIGNAL_FUNC(cb_itemsignal), "select");
397 gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
398 GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
399 gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
400 GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
401 gtk_signal_connect (GTK_OBJECT(aitem), "expand",
402 GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
403 gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
404 GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
405 /* Add it to the parent tree */
406 gtk_tree_append (GTK_TREE(real_tree), aitem);
407
408 gtk_widget_show (aitem);
409
410 gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
411
412 fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
413
414 if (dirp->smbc_type != SMBC_FILE &&
415 dirp->smbc_type != SMBC_IPC_SHARE &&
416 (strcmp(dirp->name, ".") != 0) &&
417 (strcmp(dirp->name, "..") !=0)){
418
419 subtree = gtk_tree_new();
420 gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
421
422 gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
423 GTK_SIGNAL_FUNC(cb_select_child), real_tree);
424 gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
425 GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
426
427 }
428
429 (char *)dirp += dirlen;
430 err -= dirlen;
431
432 }
433
434 }
435
436 smbc_closedir(dh);
437
438 }
439 else if (strncmp(signame, "collapse", 8) == 0) {
440 GtkWidget *subtree = gtk_tree_new();
441
442 gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
443
444 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
445
446 gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
447 GTK_SIGNAL_FUNC(cb_select_child), real_tree);
448 gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
449 GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
450
451 }
452
453}
454
455static void cb_selection_changed( GtkWidget *tree )
456{
457 GList *i;
458
459 g_print ("selection_change called for tree %p\n", tree);
460 g_print ("selected objects are:\n");
461
462 i = GTK_TREE_SELECTION(tree);
463 while (i){
464 gchar *name;
465 GtkLabel *label;
466 GtkWidget *item;
467
468 /* Get a GtkWidget pointer from the list node */
469 item = GTK_WIDGET (i->data);
470 label = GTK_LABEL (GTK_BIN (item)->child);
471 gtk_label_get (label, &name);
472 g_print ("\t%s on level %d\n", name, GTK_TREE
473 (item->parent)->level);
474 i = i->next;
475 }
476}
477
478/*
479 * Expand or collapse the whole network ...
480 */
481static void cb_wholenet(GtkWidget *item, gchar *signame)
482{
483 GtkWidget *real_tree, *aitem, *subtree;
484 gchar *name;
485 GtkLabel *label;
486 gint dh, err, dirlen;
487 char dirbuf[512];
488 struct smbc_dirent *dirp;
489
490 label = GTK_LABEL (GTK_BIN (item)->child);
491 gtk_label_get (label, &name);
492 g_print ("%s called for item %s->%p, level %d\n", signame, name,
493 item, GTK_TREE (item->parent)->level);
494
495 real_tree = GTK_TREE_ITEM_SUBTREE(item); /* Get the subtree */
496
497 if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
498
499 if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
500
501 g_print("cb_wholenet: Could not open dir smbc://, %s\n",
502 strerror(errno));
503
504 gtk_main_quit();
505
506 return;
507
508 }
509
510 while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
511 sizeof(dirbuf))) != 0) {
512
513 if (err < 0) { /* An error, report it */
514
515 g_print("cb_wholenet: Could not read dir smbc://, %s\n",
516 strerror(errno));
517
518 gtk_main_quit();
519
520 return;
521
522 }
523
524 dirp = (struct smbc_dirent *)dirbuf;
525
526 while (err > 0) {
527 struct tree_data *my_data;
528
529 dirlen = dirp->dirlen;
530
531 my_data = make_tree_data(dirp->smbc_type, dirp->name);
532
533 aitem = gtk_tree_item_new_with_label(dirp->name);
534
535 /* Connect all GtkItem:: and GtkTreeItem:: signals */
536 gtk_signal_connect (GTK_OBJECT(aitem), "select",
537 GTK_SIGNAL_FUNC(cb_itemsignal), "select");
538 gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
539 GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
540 gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
541 GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
542 gtk_signal_connect (GTK_OBJECT(aitem), "expand",
543 GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
544 gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
545 GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
546
547 gtk_tree_append (GTK_TREE(real_tree), aitem);
548 /* Show it - this can be done at any time */
549 gtk_widget_show (aitem);
550
551 gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
552
553 fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
554
555 subtree = gtk_tree_new();
556
557 gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
558
559 gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
560 GTK_SIGNAL_FUNC(cb_select_child), real_tree);
561 gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
562 GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
563
564 (char *)dirp += dirlen;
565 err -= dirlen;
566
567 }
568
569 }
570
571 smbc_closedir(dh);
572
573 }
574 else { /* Must be collapse ... FIXME ... */
575 GtkWidget *subtree = gtk_tree_new();
576
577 gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
578
579 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
580
581 gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
582 GTK_SIGNAL_FUNC(cb_select_child), real_tree);
583 gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
584 GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
585
586
587 }
588
589}
590
591/* Should put up a dialog box to ask the user for username and password */
592
593static void
594auth_fn(const char *server, const char *share,
595 char *workgroup, int wgmaxlen, char *username, int unmaxlen,
596 char *password, int pwmaxlen)
597{
598
599 strncpy(username, "test", unmaxlen);
600 strncpy(password, "test", pwmaxlen);
601
602}
603
604static char *col_titles[] = {
605 "Name", "Attributes", "Size", "Modification Date",
606};
607
608int main( int argc,
609 char *argv[] )
610{
611 GtkWidget *window, *scrolled_win, *scrolled_win2, *tree;
612 GtkWidget *subtree, *item, *main_hbox, *r_pane, *l_pane;
613 gint err, dh;
614 gint i;
615 char dirbuf[512];
616 struct smbc_dirent *dirp;
617 TALLOC_CTX *frame = talloc_stackframe();
618
619 gtk_init (&argc, &argv);
620
621 /* Init the smbclient library */
622
623 err = smbc_init(auth_fn, 10);
624
625 /* Print an error response ... */
626
627 if (err < 0) {
628
629 fprintf(stderr, "smbc_init returned %s (%i)\nDo you have a ~/.smb/smb.conf file?\n", strerror(errno), errno);
630 exit(1);
631
632 }
633
634 /* a generic toplevel window */
635 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
636 gtk_widget_set_name(window, "main browser window");
637 gtk_signal_connect (GTK_OBJECT(window), "delete_event",
638 GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
639 gtk_window_set_title(GTK_WINDOW(window), "The Linux Windows Network Browser");
640 gtk_widget_set_usize(GTK_WIDGET(window), 750, -1);
641 gtk_container_set_border_width (GTK_CONTAINER(window), 5);
642
643 gtk_widget_show (window);
644
645 /* A container for the two panes ... */
646
647 main_hbox = gtk_hbox_new(FALSE, 1);
648 gtk_container_border_width(GTK_CONTAINER(main_hbox), 1);
649 gtk_container_add(GTK_CONTAINER(window), main_hbox);
650
651 gtk_widget_show(main_hbox);
652
653 l_pane = gtk_hpaned_new();
654 gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
655 r_pane = gtk_hpaned_new();
656 gtk_paned_gutter_size(GTK_PANED(r_pane), (GTK_PANED(r_pane))->handle_size);
657 gtk_container_add(GTK_CONTAINER(main_hbox), l_pane);
658 gtk_widget_show(l_pane);
659
660 /* A generic scrolled window */
661 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
662 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
663 GTK_POLICY_AUTOMATIC,
664 GTK_POLICY_AUTOMATIC);
665 gtk_widget_set_usize (scrolled_win, 150, 200);
666 gtk_container_add (GTK_CONTAINER(l_pane), scrolled_win);
667 gtk_widget_show (scrolled_win);
668
669 /* Another generic scrolled window */
670 scrolled_win2 = gtk_scrolled_window_new (NULL, NULL);
671 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win2),
672 GTK_POLICY_AUTOMATIC,
673 GTK_POLICY_AUTOMATIC);
674 gtk_widget_set_usize (scrolled_win2, 150, 200);
675 gtk_paned_add2 (GTK_PANED(l_pane), scrolled_win2);
676 gtk_widget_show (scrolled_win2);
677
678 /* Create the root tree */
679 tree = gtk_tree_new();
680 g_print ("root tree is %p\n", tree);
681 /* connect all GtkTree:: signals */
682 gtk_signal_connect (GTK_OBJECT(tree), "select_child",
683 GTK_SIGNAL_FUNC(cb_select_child), tree);
684 gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
685 GTK_SIGNAL_FUNC(cb_unselect_child), tree);
686 gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
687 GTK_SIGNAL_FUNC(cb_selection_changed), tree);
688 /* Add it to the scrolled window */
689 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
690 tree);
691 /* Set the selection mode */
692 gtk_tree_set_selection_mode (GTK_TREE(tree),
693 GTK_SELECTION_MULTIPLE);
694 /* Show it */
695 gtk_widget_show (tree);
696
697 /* Now, create a clist and attach it to the second pane */
698
699 clist = gtk_clist_new_with_titles(4, col_titles);
700
701 gtk_container_add (GTK_CONTAINER(scrolled_win2), clist);
702
703 gtk_widget_show(clist);
704
705 /* Now, build the top level display ... */
706
707 if ((dh = smbc_opendir("smb:///")) < 0) {
708
709 fprintf(stderr, "Could not list default workgroup: smb:///: %s\n",
710 strerror(errno));
711
712 exit(1);
713
714 }
715
716 /* Create a tree item for Whole Network */
717
718 item = gtk_tree_item_new_with_label ("Whole Network");
719 /* Connect all GtkItem:: and GtkTreeItem:: signals */
720 gtk_signal_connect (GTK_OBJECT(item), "select",
721 GTK_SIGNAL_FUNC(cb_itemsignal), "select");
722 gtk_signal_connect (GTK_OBJECT(item), "deselect",
723 GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
724 gtk_signal_connect (GTK_OBJECT(item), "toggle",
725 GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
726 gtk_signal_connect (GTK_OBJECT(item), "expand",
727 GTK_SIGNAL_FUNC(cb_wholenet), "expand");
728 gtk_signal_connect (GTK_OBJECT(item), "collapse",
729 GTK_SIGNAL_FUNC(cb_wholenet), "collapse");
730 /* Add it to the parent tree */
731 gtk_tree_append (GTK_TREE(tree), item);
732 /* Show it - this can be done at any time */
733 gtk_widget_show (item);
734
735 subtree = gtk_tree_new(); /* A subtree for Whole Network */
736
737 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
738
739 gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
740 GTK_SIGNAL_FUNC(cb_select_child), tree);
741 gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
742 GTK_SIGNAL_FUNC(cb_unselect_child), tree);
743
744 /* Now, get the items in smb:/// and add them to the tree */
745
746 dirp = (struct smbc_dirent *)dirbuf;
747
748 while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
749 sizeof(dirbuf))) != 0) {
750
751 if (err < 0) { /* Handle the error */
752
753 fprintf(stderr, "Could not read directory for smbc:///: %s\n",
754 strerror(errno));
755
756 exit(1);
757
758 }
759
760 fprintf(stdout, "Dir len: %u\n", err);
761
762 while (err > 0) { /* Extract each entry and make a sub-tree */
763 struct tree_data *my_data;
764 int dirlen = dirp->dirlen;
765
766 my_data = make_tree_data(dirp->smbc_type, dirp->name);
767
768 item = gtk_tree_item_new_with_label(dirp->name);
769 /* Connect all GtkItem:: and GtkTreeItem:: signals */
770 gtk_signal_connect (GTK_OBJECT(item), "select",
771 GTK_SIGNAL_FUNC(cb_itemsignal), "select");
772 gtk_signal_connect (GTK_OBJECT(item), "deselect",
773 GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
774 gtk_signal_connect (GTK_OBJECT(item), "toggle",
775 GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
776 gtk_signal_connect (GTK_OBJECT(item), "expand",
777 GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
778 gtk_signal_connect (GTK_OBJECT(item), "collapse",
779 GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
780 /* Add it to the parent tree */
781 gtk_tree_append (GTK_TREE(tree), item);
782 /* Show it - this can be done at any time */
783 gtk_widget_show (item);
784
785 gtk_object_set_user_data(GTK_OBJECT(item), (gpointer)my_data);
786
787 fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
788
789 subtree = gtk_tree_new();
790
791 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
792
793 gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
794 GTK_SIGNAL_FUNC(cb_select_child), tree);
795 gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
796 GTK_SIGNAL_FUNC(cb_unselect_child), tree);
797
798 (char *)dirp += dirlen;
799 err -= dirlen;
800
801 }
802
803 }
804
805 smbc_closedir(dh); /* FIXME, check for error :-) */
806
807 /* Show the window and loop endlessly */
808 gtk_main();
809 TALLOC_FREE(frame);
810 return 0;
811}
812/* example-end */
Note: See TracBrowser for help on using the repository browser.