s4:dsdb/common: add samdb_domain_guid() helper function
[samba.git] / libgpo / gpo_filesync.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  Group Policy Object Support
4  *  Copyright (C) Guenther Deschner 2006
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
20 #include "includes.h"
21 #include "system/filesys.h"
22 #include "libsmb/libsmb.h"
23 #include "../libgpo/gpo.h"
24 #include "libgpo/gpo_proto.h"
25
26 struct sync_context {
27         TALLOC_CTX *mem_ctx;
28         struct cli_state *cli;
29         char *remote_path;
30         char *local_path;
31         char *mask;
32         uint16_t attribute;
33 };
34
35 static NTSTATUS gpo_sync_func(const char *mnt,
36                           struct file_info *info,
37                           const char *mask,
38                           void *state);
39
40 NTSTATUS gpo_copy_file(TALLOC_CTX *mem_ctx,
41                        struct cli_state *cli,
42                        const char *nt_path,
43                        const char *unix_path)
44 {
45         NTSTATUS result;
46         uint16_t fnum;
47         int fd = -1;
48         char *data = NULL;
49         static int io_bufsize = 64512;
50         int read_size = io_bufsize;
51         off_t nread = 0;
52
53         result = cli_open(cli, nt_path, O_RDONLY, DENY_NONE, &fnum);
54         if (!NT_STATUS_IS_OK(result)) {
55                 goto out;
56         }
57
58         if ((fd = open(unix_path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1) {
59                 result = map_nt_error_from_unix(errno);
60                 goto out;
61         }
62
63         if ((data = (char *)SMB_MALLOC(read_size)) == NULL) {
64                 result = NT_STATUS_NO_MEMORY;
65                 goto out;
66         }
67
68         while (1) {
69                 size_t n = 0;
70
71                 result = cli_read(cli, fnum, data, nread, read_size, &n);
72                 if (!NT_STATUS_IS_OK(result)) {
73                         goto out;
74                 }
75
76                 if (n == 0)
77                         break;
78
79                 if (write(fd, data, n) != n) {
80                         break;
81                 }
82
83                 nread += n;
84         }
85
86         result = NT_STATUS_OK;
87
88  out:
89         SAFE_FREE(data);
90         if (fnum) {
91                 cli_close(cli, fnum);
92         }
93         if (fd != -1) {
94                 close(fd);
95         }
96
97         return result;
98 }
99
100 /****************************************************************
101  copy dir
102 ****************************************************************/
103
104 static NTSTATUS gpo_copy_dir(const char *unix_path)
105 {
106         if ((mkdir(unix_path, 0644)) < 0 && errno != EEXIST) {
107                 return map_nt_error_from_unix(errno);
108         }
109
110         return NT_STATUS_OK;
111 }
112
113 /****************************************************************
114  sync files
115 ****************************************************************/
116
117 static NTSTATUS gpo_sync_files(struct sync_context *ctx)
118 {
119         NTSTATUS status;
120
121         DEBUG(3,("calling cli_list with mask: %s\n", ctx->mask));
122
123         status = cli_list(ctx->cli, ctx->mask, ctx->attribute, gpo_sync_func,
124                           ctx);
125         if (!NT_STATUS_IS_OK(status)) {
126                 DEBUG(1, ("listing [%s] failed with error: %s\n",
127                           ctx->mask, nt_errstr(status)));
128                 return status;
129         }
130
131         return status;
132 }
133
134 /****************************************************************
135  syncronisation call back
136 ****************************************************************/
137
138 static NTSTATUS gpo_sync_func(const char *mnt,
139                           struct file_info *info,
140                           const char *mask,
141                           void *state)
142 {
143         NTSTATUS result;
144         struct sync_context *ctx;
145         fstring nt_filename, unix_filename;
146         fstring nt_dir, unix_dir;
147         char *old_nt_dir, *old_unix_dir;
148
149         ctx = (struct sync_context *)state;
150
151         if (strequal(info->name, ".") || strequal(info->name, "..")) {
152                 return NT_STATUS_OK;
153         }
154
155         DEBUG(5,("gpo_sync_func: got mask: [%s], name: [%s]\n",
156                 mask, info->name));
157
158         if (info->mode & FILE_ATTRIBUTE_DIRECTORY) {
159
160                 DEBUG(3,("got dir: [%s]\n", info->name));
161
162                 fstrcpy(nt_dir, ctx->remote_path);
163                 fstrcat(nt_dir, "\\");
164                 fstrcat(nt_dir, info->name);
165
166                 fstrcpy(unix_dir, ctx->local_path);
167                 fstrcat(unix_dir, "/");
168                 fstrcat(unix_dir, info->name);
169
170                 result = gpo_copy_dir(unix_dir);
171                 if (!NT_STATUS_IS_OK(result)) {
172                         DEBUG(1,("failed to copy dir: %s\n",
173                                 nt_errstr(result)));
174                         return result;
175                 }
176
177                 old_nt_dir = ctx->remote_path;
178                 ctx->remote_path = talloc_strdup(ctx->mem_ctx, nt_dir);
179
180                 old_unix_dir = ctx->local_path;
181                 ctx->local_path = talloc_strdup(ctx->mem_ctx, unix_dir);
182
183                 ctx->mask = talloc_asprintf(ctx->mem_ctx,
184                                         "%s\\*",
185                                         nt_dir);
186                 if (!ctx->local_path || !ctx->mask || !ctx->remote_path) {
187                         DEBUG(0,("gpo_sync_func: ENOMEM\n"));
188                         return NT_STATUS_NO_MEMORY;
189                 }
190                 result = gpo_sync_files(ctx);
191                 if (!NT_STATUS_IS_OK(result)) {
192                         DEBUG(0,("could not sync files\n"));
193                         return result;
194                 }
195
196                 ctx->remote_path = old_nt_dir;
197                 ctx->local_path = old_unix_dir;
198                 return NT_STATUS_OK;
199         }
200
201         DEBUG(3,("got file: [%s]\n", info->name));
202
203         fstrcpy(nt_filename, ctx->remote_path);
204         fstrcat(nt_filename, "\\");
205         fstrcat(nt_filename, info->name);
206
207         fstrcpy(unix_filename, ctx->local_path);
208         fstrcat(unix_filename, "/");
209         fstrcat(unix_filename, info->name);
210
211         result = gpo_copy_file(ctx->mem_ctx, ctx->cli,
212                                nt_filename, unix_filename);
213         if (!NT_STATUS_IS_OK(result)) {
214                 DEBUG(1,("failed to copy file: %s\n",
215                         nt_errstr(result)));
216         }
217         return result;
218 }
219
220
221 /****************************************************************
222  list a remote directory and download recursivly
223 ****************************************************************/
224
225 NTSTATUS gpo_sync_directories(TALLOC_CTX *mem_ctx,
226                               struct cli_state *cli,
227                               const char *nt_path,
228                               const char *local_path)
229 {
230         struct sync_context ctx;
231
232         ctx.mem_ctx     = mem_ctx;
233         ctx.cli         = cli;
234         ctx.remote_path = discard_const_p(char, nt_path);
235         ctx.local_path  = discard_const_p(char, local_path);
236         ctx.attribute   = (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY);
237
238         ctx.mask = talloc_asprintf(mem_ctx,
239                                 "%s\\*",
240                                 nt_path);
241         if (!ctx.mask) {
242                 return NT_STATUS_NO_MEMORY;
243         }
244
245         return gpo_sync_files(&ctx);
246 }