Line data Source code
1 : #include "../../burp.h"
2 : #include "../../alloc.h"
3 : #include "../../cmd.h"
4 : #include "../../fsops.h"
5 : #include "../../hexmap.h"
6 : #include "../../iobuf.h"
7 : #include "../../lock.h"
8 : #include "../../log.h"
9 : #include "../../prepend.h"
10 : #include "../../protocol2/blk.h"
11 : #include "dpth.h"
12 :
13 15 : static int get_data_lock(struct lock *lock, const char *path)
14 : {
15 15 : int ret=-1;
16 15 : char *lockfile=NULL;
17 : // Use just the first three components, excluding sig number.
18 15 : if(!(lockfile=prepend(path, ".lock")))
19 : goto end;
20 15 : if(lock_init(lock, lockfile)
21 15 : || build_path_w(lock->path))
22 : goto end;
23 15 : lock_get_quick(lock);
24 15 : ret=0;
25 : end:
26 15 : free_w(&lockfile);
27 15 : return ret;
28 : }
29 :
30 : static char *dpth_mk_prim(struct dpth *dpth)
31 : {
32 : static char path[8];
33 39 : snprintf(path, sizeof(path), "%04X", dpth->comp[0]);
34 : return path;
35 : }
36 :
37 : static char *dpth_mk_seco(struct dpth *dpth)
38 : {
39 : static char path[16];
40 39 : snprintf(path, sizeof(path), "%04X/%04X", dpth->comp[0], dpth->comp[1]);
41 : return path;
42 : }
43 :
44 11 : static struct dpth_lock *dpth_lock_alloc(const char *save_path)
45 : {
46 : struct dpth_lock *dpth_lock;
47 11 : if(!(dpth_lock=(struct dpth_lock *)
48 : calloc_w(1, sizeof(struct dpth_lock), __func__)))
49 : return NULL;
50 11 : snprintf(dpth_lock->save_path, sizeof(dpth_lock->save_path),
51 : "%s", save_path);
52 11 : return dpth_lock;
53 : }
54 :
55 11 : static int add_lock_to_list(struct dpth *dpth,
56 : struct lock *lock, const char *save_path)
57 : {
58 : struct dpth_lock *dlnew;
59 11 : if(!(dlnew=dpth_lock_alloc(save_path))) return -1;
60 11 : dlnew->lock=lock;
61 :
62 : // Add to the end of the list.
63 11 : if(dpth->tail) dpth->tail->next=dlnew;
64 8 : else if(!dpth->head) dpth->head=dlnew;
65 11 : dpth->tail=dlnew;
66 : return 0;
67 : }
68 :
69 8538 : char *dpth_protocol2_get_save_path(struct dpth *dpth)
70 : {
71 : static char save_path[32];
72 34152 : snprintf(save_path, sizeof(save_path), "%04X/%04X/%04X/%04X",
73 34152 : dpth->comp[0], dpth->comp[1], dpth->comp[2], dpth->comp[3]);
74 8538 : return save_path;
75 : }
76 :
77 8527 : char *dpth_protocol2_mk(struct dpth *dpth)
78 : {
79 8527 : char *p=NULL;
80 : static char *save_path=NULL;
81 : static struct lock *lock=NULL;
82 : struct stat statp;
83 :
84 : while(1)
85 : {
86 8531 : free_w(&p);
87 8531 : save_path=dpth_protocol2_get_save_path(dpth);
88 8531 : if(!dpth->need_data_lock)
89 : return save_path;
90 :
91 15 : if(!lock && !(lock=lock_alloc()))
92 : goto error;
93 :
94 : // Use just the first three components, excluding sig number.
95 15 : if(!(p=prepend_slash(dpth->base_path, save_path, 14)))
96 : goto error;
97 :
98 15 : if(get_data_lock(lock, p))
99 : goto error;
100 :
101 15 : switch(lock->status)
102 : {
103 : case GET_LOCK_GOT:
104 28 : if(lstat(p, &statp))
105 : {
106 : // File does not exist yet, and we
107 : // have the lock. All good.
108 : break;
109 : }
110 : // The file that we want to write already
111 : // exists.
112 3 : if(lock_release(lock))
113 : goto error;
114 3 : lock_free(&lock);
115 : // Fall through and try again.
116 : case GET_LOCK_NOT_GOT:
117 : // Increment and try again.
118 4 : if(dpth_incr(dpth))
119 : goto error;
120 4 : continue;
121 : case GET_LOCK_ERROR:
122 : default:
123 : goto error;
124 : }
125 :
126 11 : dpth->need_data_lock=0; // Got it.
127 11 : if(add_lock_to_list(dpth, lock, save_path))
128 : goto error;
129 11 : lock=NULL;
130 11 : free_w(&p);
131 11 : return save_path;
132 4 : }
133 : error:
134 0 : free_w(&p);
135 0 : lock_free(&lock);
136 0 : return NULL;
137 : }
138 :
139 : // Returns 0 on OK, -1 on error. *max gets set to the next entry.
140 153 : int get_highest_entry(const char *path, int *max, size_t len)
141 : {
142 153 : int ent=0;
143 153 : int ret=0;
144 153 : DIR *d=NULL;
145 153 : struct dirent *dp=NULL;
146 :
147 153 : *max=-1;
148 153 : if(!(d=opendir(path))) goto end;
149 229 : while((dp=readdir(d)))
150 : {
151 174 : if(!dp->d_ino
152 174 : || strlen(dp->d_name)!=len)
153 150 : continue;
154 24 : ent=strtol(dp->d_name, NULL, 16);
155 24 : if(ent>*max) *max=ent;
156 : }
157 :
158 : end:
159 153 : if(d) closedir(d);
160 153 : return ret;
161 : }
162 :
163 16725 : int dpth_protocol2_incr_sig(struct dpth *dpth)
164 : {
165 16725 : if(++dpth->comp[3]<DATA_FILE_SIG_MAX) return 0;
166 9 : dpth->comp[3]=0;
167 9 : dpth->need_data_lock=1;
168 9 : return dpth_incr(dpth);
169 : }
170 :
171 39 : static int open_cfile_fzp(struct dpth *dpth,
172 : const char *cname, const char *cfiles)
173 : {
174 : int fd;
175 39 : int ret=-1;
176 39 : char *fname=NULL;
177 39 : char *fullpath=NULL;
178 :
179 39 : if(!(fname=prepend(cname, "XXXXXX")))
180 : goto end;
181 39 : if(!(fullpath=prepend_s(cfiles, fname)))
182 : goto end;
183 39 : if(build_path_w(fullpath))
184 : goto end;
185 39 : if((fd=mkstemp(fullpath))<0)
186 : {
187 0 : logp("Could not mkstemp from template %s: %s\n",
188 0 : fullpath, strerror(errno));
189 : goto end;
190 : }
191 39 : if(!(dpth->cfile_fzp=fzp_dopen(fd, "wb")))
192 : goto end;
193 :
194 39 : ret=0;
195 : end:
196 39 : free_w(&fname);
197 39 : free_w(&fullpath);
198 39 : return ret;
199 : }
200 :
201 117 : int dpth_protocol2_init(struct dpth *dpth, const char *base_path,
202 : const char *cname, const char *cfiles, int max_storage_subdirs)
203 : {
204 : int max;
205 39 : int ret=0;
206 39 : char *tmp=NULL;
207 :
208 39 : if(!base_path)
209 : {
210 0 : logp("No base_path supplied in %s()\n", __func__);
211 0 : goto error;
212 : }
213 :
214 39 : if(open_cfile_fzp(dpth, cname, cfiles)) goto error;
215 :
216 39 : dpth->max_storage_subdirs=max_storage_subdirs;
217 :
218 39 : free_w(&dpth->base_path);
219 39 : if(!(dpth->base_path=strdup_w(base_path, __func__)))
220 : goto error;
221 :
222 39 : dpth->savepath=0;
223 39 : dpth->need_data_lock=1;
224 :
225 39 : if(get_highest_entry(dpth->base_path, &max, 4))
226 : goto error;
227 39 : if(max<0) max=0;
228 39 : dpth->comp[0]=max;
229 78 : tmp=dpth_mk_prim(dpth);
230 39 : if(!(tmp=prepend_s(dpth->base_path, tmp)))
231 : goto error;
232 :
233 39 : if(get_highest_entry(tmp, &max, 4))
234 : goto error;
235 39 : if(max<0) max=0;
236 39 : dpth->comp[1]=max;
237 39 : free_w(&tmp);
238 117 : tmp=dpth_mk_seco(dpth);
239 39 : if(!(tmp=prepend_s(dpth->base_path, tmp)))
240 : goto error;
241 :
242 39 : if(get_highest_entry(tmp, &max, 4))
243 : goto error;
244 39 : if(max<0)
245 : {
246 31 : dpth->comp[2]=0;
247 : }
248 : else
249 : {
250 8 : dpth->comp[2]=max;
251 8 : if(dpth_incr(dpth)) goto error;
252 : }
253 :
254 : goto end;
255 : error:
256 : ret=-1;
257 : end:
258 39 : free_w(&tmp);
259 39 : return ret;
260 : }
261 :
262 16713 : static int fprint_tag(struct fzp *fzp, enum cmd cmd, unsigned int s)
263 : {
264 16713 : if(fzp_printf(fzp, "%c%04X", cmd, s)!=5)
265 : {
266 0 : logp("Short fprintf\n");
267 0 : return -1;
268 : }
269 : return 0;
270 : }
271 :
272 16713 : static int fwrite_buf(enum cmd cmd,
273 : const char *buf, unsigned int s, struct fzp *fzp)
274 : {
275 : static size_t bytes;
276 16713 : if(fprint_tag(fzp, cmd, s)) return -1;
277 16713 : if((bytes=fzp_write(fzp, buf, s))!=s)
278 : {
279 0 : logp("Short write: %d\n", (int)bytes);
280 0 : return -1;
281 : }
282 : return 0;
283 : }
284 :
285 9 : static struct fzp *file_open_w(const char *path)
286 : {
287 9 : if(build_path_w(path)) return NULL;
288 9 : return fzp_open(path, "wb");
289 : }
290 :
291 9 : static int write_to_cfile(struct dpth *dpth, struct blk *blk)
292 : {
293 : struct iobuf wbuf;
294 9 : blk_to_iobuf_savepath(blk, &wbuf);
295 9 : if(iobuf_send_msg_fzp(&wbuf, dpth->cfile_fzp))
296 : return -1;
297 9 : if(fzp_flush(dpth->cfile_fzp))
298 : return -1;
299 9 : if(fsync(fzp_fileno(dpth->cfile_fzp)))
300 : {
301 0 : logp("fsync on cfile_fzp failed: %s\n", strerror(errno));
302 : return -1;
303 : }
304 : return 0;
305 : }
306 :
307 9 : static struct fzp *open_data_file_for_write(struct dpth *dpth, struct blk *blk)
308 : {
309 9 : char *path=NULL;
310 9 : struct fzp *fzp=NULL;
311 9 : char *savepathstr=NULL;
312 9 : struct dpth_lock *head=dpth->head;
313 :
314 9 : savepathstr=uint64_to_savepathstr(blk->savepath);
315 :
316 : // Sanity check. They should be coming through from the client
317 : // in the same order in which we locked them.
318 : // Remember that the save_path on the lock list is shorter than the
319 : // full save_path on the blk.
320 9 : if(!head
321 9 : || strncmp(head->save_path,
322 : //FIX THIS
323 : savepathstr, sizeof(head->save_path)-1))
324 : {
325 0 : logp("lock and block save_path mismatch: %s %s\n",
326 : head?head->save_path:"(null)", savepathstr);
327 0 : goto end;
328 : }
329 :
330 9 : if(!(path=prepend_slash(dpth->base_path, savepathstr, 14)))
331 : goto end;
332 9 : if(write_to_cfile(dpth, blk))
333 : goto end;
334 9 : fzp=file_open_w(path);
335 : end:
336 9 : free_w(&path);
337 9 : return fzp;
338 : }
339 :
340 16713 : int dpth_protocol2_fwrite(struct dpth *dpth,
341 : struct iobuf *iobuf, struct blk *blk)
342 : {
343 : // Remember that the save_path on the lock list is shorter than the
344 : // full save_path on the blk.
345 16713 : if(dpth->fzp
346 16705 : && strncmp(dpth->head->save_path,
347 : uint64_to_savepathstr(blk->savepath),
348 : sizeof(dpth->head->save_path)-1)
349 1 : && dpth_release_and_move_to_next_in_list(dpth))
350 : return -1;
351 :
352 : // Open the current list head if we have no fzp.
353 16713 : if(!dpth->fzp
354 9 : && !(dpth->fzp=open_data_file_for_write(dpth, blk))) return -1;
355 :
356 16713 : return fwrite_buf(CMD_DATA, iobuf->buf, iobuf->len, dpth->fzp);
357 : }
|
