← Back to branch summary

~ubuntu-branches/debian/sid/obnam/sid

« back to all changes in this revision

Viewing changes to _obnammodule.c

  • Committer: Package Import Robot
  • Author(s): Lars Wirzenius
  • Date: 2013-11-30 11:18:48 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20131130111848-393of9hf0s2ohtlv
Tags: 1.6-1
http://bugs.debian.org/726808
http://bugs.debian.org/683868
http://bugs.debian.org/684349
http://bugs.debian.org/705554
http://bugs.debian.org/722553
* New upstream version.
  - Adds a better example for "obnam mount" (Closes: #726808)
  - Explain --log-max units in manpage (Closes:  #683868)
  - Fix bug for sftp URL handling of /~/ for home dirs 
    (Closes: #684349)
  - Missing node problem fixes (Closes: #705554)
* Add Depends and Build-Depends on python-fuse. (Closes: #722553)

Show diffs side-by-side

added added

removed removed

Lines of Context:
_obnammodule.c
45
45
#include <stdio.h>
46
46
#include <sys/types.h>
47
47
#include <sys/stat.h>
48
 
#include <sys/xattr.h>
49
48
#include <unistd.h>
50
49
#include <stdlib.h>
51
50
 
 
51
#ifdef __FreeBSD__
 
52
    #include <sys/extattr.h>
 
53
    #define NO_NANOSECONDS 1
 
54
#else
 
55
    #include <sys/xattr.h>
 
56
    #define NO_NANOSECONDS 0
 
57
#endif
 
58
 
52
59
 
53
60
static PyObject *
54
61
fadvise_dontneed(PyObject *self, PyObject *args)
78
85
    const char *filename;
79
86
    long atime_sec, atime_nsec;
80
87
    long mtime_sec, mtime_nsec;
 
88
#if NO_NANOSECONDS
 
89
    struct timeval tv[2];
 
90
#else
81
91
    struct timespec tv[2];
82
 
 
 
92
#endif
83
93
    if (!PyArg_ParseTuple(args, "sllll",
84
94
                          &filename,
85
95
                          &atime_sec,
88
98
                          &mtime_nsec))
89
99
        return NULL;
90
100
 
 
101
#if NO_NANOSECONDS
 
102
    tv[0].tv_sec = atime_sec;
 
103
    tv[0].tv_usec = atime_nsec / 1000;
 
104
    tv[1].tv_sec = mtime_sec;
 
105
    tv[1].tv_usec = mtime_nsec / 1000;
 
106
    ret = lutimes(filename, tv);
 
107
#else
91
108
    tv[0].tv_sec = atime_sec;
92
109
    tv[0].tv_nsec = atime_nsec;
93
110
    tv[1].tv_sec = mtime_sec;
94
111
    tv[1].tv_nsec = mtime_nsec;
95
112
    ret = utimensat(AT_FDCWD, filename, tv, AT_SYMLINK_NOFOLLOW);
 
113
#endif
96
114
    if (ret == -1)
97
115
        ret = errno;
98
116
    return Py_BuildValue("i", ret);
99
117
}
100
118
 
101
119
 
 
120
/*
 
121
 * Since we can't set nanosecond mtime and atimes on some platforms, also
 
122
 * don't retrieve that level of precision from lstat(), so comparisons
 
123
 * work.
 
124
 */
 
125
static unsigned long long
 
126
remove_precision(unsigned long long nanoseconds)
 
127
{
 
128
#if NO_NANOSECONDS
 
129
    return nanoseconds - (nanoseconds % 1000);
 
130
#else
 
131
    return nanoseconds;
 
132
#endif
 
133
}
 
134
 
 
135
 
102
136
static PyObject *
103
137
lstat_wrapper(PyObject *self, PyObject *args)
104
138
{
126
160
                         (long long) st.st_blksize,
127
161
                         (long long) st.st_blocks,
128
162
                         (long long) st.st_atim.tv_sec,
129
 
                         (unsigned long long) st.st_atim.tv_nsec,
 
163
                         remove_precision(st.st_atim.tv_nsec),
130
164
                         (long long) st.st_mtim.tv_sec,
131
 
                         (unsigned long long) st.st_mtim.tv_nsec,
 
165
                         remove_precision(st.st_mtim.tv_nsec),
132
166
                         (long long) st.st_ctim.tv_sec,
133
 
                         (unsigned long long) st.st_ctim.tv_nsec);
 
167
                         remove_precision(st.st_ctim.tv_nsec));
134
168
}
135
169
 
136
170
 
140
174
    const char *filename;
141
175
    size_t bufsize;
142
176
    PyObject *o;
 
177
    char* buf;
 
178
    ssize_t n;
143
179
 
144
180
    if (!PyArg_ParseTuple(args, "s", &filename))
145
181
        return NULL;
146
182
 
 
183
#ifdef __FreeBSD__
 
184
    bufsize = extattr_list_link(filename, EXTATTR_NAMESPACE_USER, NULL, 0);
 
185
    buf = malloc(bufsize);
 
186
    n = extattr_list_link(filename, EXTATTR_NAMESPACE_USER, buf, bufsize);
 
187
    if (n >= 0) {
 
188
         /* Convert from length-prefixed BSD style to '\0'-suffixed
 
189
            Linux style. */
 
190
         size_t i = 0;
 
191
         while (i < n) {
 
192
             unsigned char length = (unsigned char) buf[i];
 
193
             memmove(buf + i, buf + i + 1, length);
 
194
             buf[i + length] = '\0';
 
195
             i += length + 1;
 
196
         }
 
197
         o = Py_BuildValue("s#", buf, (int) n);
 
198
    } else {
 
199
         o = Py_BuildValue("i", errno);
 
200
    }
 
201
    free(buf);
 
202
#else
147
203
    bufsize = 0;
148
204
    o = NULL;
149
205
    do {
150
206
        bufsize += 1024;
151
 
        char *buf = malloc(bufsize);
152
 
        ssize_t n = llistxattr(filename, buf, bufsize);
 
207
        buf = malloc(bufsize);
 
208
        n = llistxattr(filename, buf, bufsize);
153
209
 
154
210
        if (n >= 0)
155
211
            o = Py_BuildValue("s#", buf, (int) n);
157
213
            o = Py_BuildValue("i", errno);
158
214
        free(buf);
159
215
    } while (o == NULL);
160
 
 
 
216
#endif
161
217
    return o;
162
218
}
163
219
 
178
234
    do {
179
235
        bufsize += 1024;
180
236
        char *buf = malloc(bufsize);
 
237
#ifdef __FreeBSD__
 
238
        int n = extattr_get_link(filename, EXTATTR_NAMESPACE_USER, attrname, buf, bufsize);
 
239
#else
181
240
        ssize_t n = lgetxattr(filename, attrname, buf, bufsize);
182
 
 
 
241
#endif
183
242
        if (n >= 0)
184
243
            o = Py_BuildValue("s#", buf, (int) n);
185
244
        else if (n == -1 && errno != ERANGE)
203
262
    if (!PyArg_ParseTuple(args, "sss#", &filename, &name, &value, &size))
204
263
        return NULL;
205
264
 
 
265
#ifdef __FreeBSD__
 
266
    ret = extattr_set_link(filename, EXTATTR_NAMESPACE_USER, name, value, size);
 
267
#else
206
268
    ret = lsetxattr(filename, name, value, size, 0);
 
269
#endif
207
270
    if (ret == -1)
208
271
        ret = errno;
209
272
    return Py_BuildValue("i", ret);