← Back to branch summary

~stefanor/ubuntu/maverick/samba/ntlm-auth-623342

« back to all changes in this revision

Viewing changes to source/utils/net_time.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2009-07-08 07:02:37 UTC
  • mfrom: (0.27.6 upstream) (0.28.6 sid)
  • Revision ID: james.westby@ubuntu.com-20090708070237-o5wxq1shz5tabuw2
Tags: 2:3.4.0-1ubuntu1
https://launchpad.net/bugs/312449
https://launchpad.net/bugs/300221
* Merge from debian unstable, remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - Add "(Samaba, Ubuntu)" to server string.
    - Comment out the default [homes] share, and add a comment 
      about "valid users = $s" to show users how to restrict access
      to \\server\username to only username.
    - Set 'usershare allow guests' so that usershare admins are
      allowed to create public shares to authenticated ones.
    - Add 'map to gues = Bad user', maps bad username to guest access.
  + debian/samba-common.conf:
    - Do not change priority to hight if dhclient3 is installed.
    - Use priority medium  instead of high for the workgroup question.
  + debian/samba-common.postinst: Add more informative error message for the case
    where smb.conf was manually deleted. (LP: #312449)
  + debian/mksambapasswd.awk: Do not add user with UID less than 1000 to smbpasswd.
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against ctdb.
    - Add suggests keyutils for smbfs. (LP: #300221)
  + debian/rules:
    - enable "native" PIE hardening.
    - remove --with-ctdb and --with-cluster-support=yes
  + Add ufw integration:
    - Created debian/samba.ufw profile.
    - debian/rules, debian/samba.dirs, debian/samba.files: install profile
    - debian/control: have samba suffest ufw
  + Dropped:
    - debian/patches/fix-password-expiry-calculation.patch: Already upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/utils/net_time.c
1
 
/*
2
 
   Samba Unix/Linux SMB client library
3
 
   net time command
4
 
   Copyright (C) 2001 Andrew Tridgell (tridge@samba.org)
5
 
 
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.
10
 
 
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.
15
 
 
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/>.
18
 
*/
19
 
#include "includes.h"
20
 
#include "utils/net.h"
21
 
 
22
 
/*
23
 
  return the time on a server. This does not require any authentication
24
 
*/
25
 
static time_t cli_servertime(const char *host, struct sockaddr_storage *pss, int *zone)
26
 
{
27
 
        struct nmb_name calling, called;
28
 
        time_t ret = 0;
29
 
        struct cli_state *cli = NULL;
30
 
        NTSTATUS status;
31
 
 
32
 
        cli = cli_initialise();
33
 
        if (!cli) {
34
 
                goto done;
35
 
        }
36
 
 
37
 
        status = cli_connect(cli, host, pss);
38
 
        if (!NT_STATUS_IS_OK(status)) {
39
 
                fprintf(stderr,"Can't contact server %s. Error %s\n", host, nt_errstr(status));
40
 
                goto done;
41
 
        }
42
 
 
43
 
        make_nmb_name(&calling, global_myname(), 0x0);
44
 
        if (host) {
45
 
                make_nmb_name(&called, host, 0x20);
46
 
        } else {
47
 
                make_nmb_name(&called, "*SMBSERVER", 0x20);
48
 
        }
49
 
 
50
 
        if (!cli_session_request(cli, &calling, &called)) {
51
 
                fprintf(stderr,"Session request failed\n");
52
 
                goto done;
53
 
        }
54
 
        if (!cli_negprot(cli)) {
55
 
                fprintf(stderr,"Protocol negotiation failed\n");
56
 
                goto done;
57
 
        }
58
 
 
59
 
        ret = cli->servertime;
60
 
        if (zone) *zone = cli->serverzone;
61
 
 
62
 
done:
63
 
        if (cli) {
64
 
                cli_shutdown(cli);
65
 
        }
66
 
        return ret;
67
 
}
68
 
 
69
 
/* find the servers time on the opt_host host */
70
 
static time_t nettime(struct net_context *c, int *zone)
71
 
{
72
 
        return cli_servertime(c->opt_host,
73
 
                              c->opt_have_ip? &c->opt_dest_ip : NULL, zone);
74
 
}
75
 
 
76
 
/* return a time as a string ready to be passed to /bin/date */
77
 
static const char *systime(time_t t)
78
 
{
79
 
        static fstring s;
80
 
        struct tm *tm;
81
 
 
82
 
        tm = localtime(&t);
83
 
        if (!tm) {
84
 
                return "unknown";
85
 
        }
86
 
 
87
 
        fstr_sprintf(s, "%02d%02d%02d%02d%04d.%02d",
88
 
                 tm->tm_mon+1, tm->tm_mday, tm->tm_hour,
89
 
                 tm->tm_min, tm->tm_year + 1900, tm->tm_sec);
90
 
        return s;
91
 
}
92
 
 
93
 
int net_time_usage(struct net_context *c, int argc, const char **argv)
94
 
{
95
 
        d_printf(
96
 
"net time\n\tdisplays time on a server\n\n"
97
 
"net time system\n\tdisplays time on a server in a format ready for /bin/date\n\n"
98
 
"net time set\n\truns /bin/date with the time from the server\n\n"
99
 
"net time zone\n\tdisplays the timezone in hours from GMT on the remote computer\n\n"
100
 
"\n");
101
 
        net_common_flags_usage(c, argc, argv);
102
 
        return -1;
103
 
}
104
 
 
105
 
/* try to set the system clock using /bin/date */
106
 
static int net_time_set(struct net_context *c, int argc, const char **argv)
107
 
{
108
 
        time_t t = nettime(c, NULL);
109
 
        char *cmd;
110
 
        int result;
111
 
 
112
 
        if (t == 0) return -1;
113
 
 
114
 
        /* yes, I know this is cheesy. Use "net time system" if you want to
115
 
           roll your own. I'm putting this in as it works on a large number
116
 
           of systems and the user has a choice in whether its used or not */
117
 
        if (asprintf(&cmd, "/bin/date %s", systime(t)) == -1) {
118
 
                return -1;
119
 
        }
120
 
        result = system(cmd);
121
 
        if (result)
122
 
                d_fprintf(stderr, "%s failed.  Error was (%s)\n",
123
 
                        cmd, strerror(errno));
124
 
        free(cmd);
125
 
 
126
 
        return result;
127
 
}
128
 
 
129
 
/* display the time on a remote box in a format ready for /bin/date */
130
 
static int net_time_system(struct net_context *c, int argc, const char **argv)
131
 
{
132
 
        time_t t;
133
 
 
134
 
        if (c->display_usage) {
135
 
                d_printf("Usage:\n"
136
 
                         "net time system\n"
137
 
                         "    Output remote time server time in a format ready "
138
 
                         "for /bin/date\n");
139
 
                return 0;
140
 
        }
141
 
 
142
 
        t = nettime(c, NULL);
143
 
        if (t == 0) return -1;
144
 
 
145
 
        printf("%s\n", systime(t));
146
 
 
147
 
        return 0;
148
 
}
149
 
 
150
 
/* display the remote time server's offset to UTC */
151
 
static int net_time_zone(struct net_context *c, int argc, const char **argv)
152
 
{
153
 
        int zone = 0;
154
 
        int hours, mins;
155
 
        char zsign;
156
 
        time_t t;
157
 
 
158
 
        if (c->display_usage) {
159
 
                d_printf("Usage:\n"
160
 
                         "net time zone\n"
161
 
                         "   Display the remote time server's offset to UTC\n");
162
 
                return 0;
163
 
        }
164
 
 
165
 
        t = nettime(c, &zone);
166
 
 
167
 
        if (t == 0) return -1;
168
 
 
169
 
        zsign = (zone > 0) ? '-' : '+';
170
 
        if (zone < 0) zone = -zone;
171
 
 
172
 
        zone /= 60;
173
 
        hours = zone / 60;
174
 
        mins = zone % 60;
175
 
 
176
 
        printf("%c%02d%02d\n", zsign, hours, mins);
177
 
 
178
 
        return 0;
179
 
}
180
 
 
181
 
/* display or set the time on a host */
182
 
int net_time(struct net_context *c, int argc, const char **argv)
183
 
{
184
 
        time_t t;
185
 
        struct functable func[] = {
186
 
                {
187
 
                        "system",
188
 
                        net_time_system,
189
 
                        NET_TRANSPORT_LOCAL,
190
 
                        "Display time ready for /bin/date",
191
 
                        "net time system\n"
192
 
                        "    Display time ready for /bin/date"
193
 
                },
194
 
                {
195
 
                        "set",
196
 
                        net_time_set,
197
 
                        NET_TRANSPORT_LOCAL,
198
 
                        "Set the system time from time server",
199
 
                        "net time set\n"
200
 
                        "    Set the system time from time server"
201
 
                },
202
 
                {
203
 
                        "zone",
204
 
                        net_time_zone,
205
 
                        NET_TRANSPORT_LOCAL,
206
 
                        "Display timezone offset from UTC",
207
 
                        "net time zone\n"
208
 
                        "    Display timezone offset from UTC"
209
 
                },
210
 
                {NULL, NULL, 0, NULL, NULL}
211
 
        };
212
 
 
213
 
        if (argc != 0) {
214
 
                return net_run_function(c, argc, argv, "net time", func);
215
 
        }
216
 
 
217
 
        if (c->display_usage) {
218
 
                d_printf("Usage:\n");
219
 
                d_printf("net time\n"
220
 
                         "    Display the remote time server's time\n");
221
 
                net_display_usage_from_functable(func);
222
 
                return 0;
223
 
        }
224
 
 
225
 
        if (!c->opt_host && !c->opt_have_ip &&
226
 
            !find_master_ip(c->opt_target_workgroup, &c->opt_dest_ip)) {
227
 
                d_fprintf(stderr, "Could not locate a time server.  Try "
228
 
                                 "specifying a target host.\n");
229
 
                net_time_usage(c, argc,argv);
230
 
                return -1;
231
 
        }
232
 
 
233
 
        /* default - print the time */
234
 
        t = cli_servertime(c->opt_host, c->opt_have_ip? &c->opt_dest_ip : NULL,
235
 
                           NULL);
236
 
        if (t == 0) return -1;
237
 
 
238
 
        d_printf("%s", ctime(&t));
239
 
        return 0;
240
 
}