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