ROX-Filer/src/xtypes.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2005, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22
  23 /*
  24  * xtypes.c - Extended filesystem attribute support for MIME types
  25  */
  26
  27 #include "config.h"
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <errno.h>
  31
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36
  37 #include <glib.h>
  38
  39 #include "global.h"
  40 #include "type.h"
  41 #include "xtypes.h"
  42 #include "options.h"
  43
  44 static Option o_xattr_ignore;
  45
  46 #define XTYPE_ATTR "user.mime_type"
  47
  48 #define RETURN_IF_IGNORED(val) if(o_xattr_ignore.int_value) return (val)
  49
  50 #if defined(HAVE_GETXATTR)
  51 /* Linux implementation */
  52
  53 #include <dlfcn.h>
  54
  55 static int (*dyn_setxattr)(const char *path, const char *name,
  56                      const void *value, size_t size, int flags) = NULL;
  57 static ssize_t (*dyn_getxattr)(const char *path, const char *name,
  58                          void *value, size_t size) = NULL;
  59 static ssize_t (*dyn_listxattr)(const char *path, char *list,
  60                          size_t size) = NULL;
  61
  62 void xattr_init(void)
  63 {
  64         void *libc;
  65
  66         libc = dlopen("libc.so.6", RTLD_LAZY | RTLD_NOLOAD);
  67         if (!libc)
  68         {
  69                 /* Try a different name for uClib support */
  70                 libc = dlopen("libc.so", RTLD_LAZY | RTLD_NOLOAD);
  71         }
  72
  73         if (!libc)
  74                 return; /* Give up on xattr support */
  75
  76         dyn_setxattr = (void *) dlsym(libc, "setxattr");
  77         dyn_getxattr = (void *) dlsym(libc, "getxattr");
  78         dyn_listxattr = (void *) dlsym(libc, "listxattr");
  79
  80         option_add_int(&o_xattr_ignore, "xattr_ignore", FALSE);
  81 }
  82
  83 int xattr_supported(const char *path)
  84 {
  85         char buf[1];
  86         ssize_t nent;
  87
  88         RETURN_IF_IGNORED(FALSE);
  89
  90         if (!dyn_getxattr)
  91                 return FALSE;
  92
  93         if(path) {
  94                 errno=0;
  95                 nent=dyn_getxattr(path, XTYPE_ATTR, buf, sizeof(buf));
  96
  97                 if(nent<0 && errno==ENOTSUP)
  98                         return FALSE;
  99         }
 100
 101         return TRUE;
 102 }
 103
 104 int xattr_have(const char *path)
 105 {
 106         char buf[1];
 107         ssize_t nent;
 108
 109         RETURN_IF_IGNORED(FALSE);
 110
 111         if (!dyn_listxattr)
 112                 return FALSE;
 113
 114         errno=0;
 115         nent=dyn_listxattr(path, buf, sizeof(buf));
 116
 117         if(nent<0 && errno==ERANGE)
 118                 return TRUE;
 119
 120         return (nent>0);
 121 }
 122
 123 gchar *xattr_get(const char *path, const char *attr, int *len)
 124 {
 125         ssize_t size;
 126         gchar *buf;
 127
 128         RETURN_IF_IGNORED(NULL);
 129
 130         if (!dyn_getxattr)
 131                 return NULL;
 132
 133         size = dyn_getxattr(path, attr, "", 0);
 134         if (size > 0)
 135         {
 136                 int new_size;
 137
 138                 buf = g_new(gchar, size + 1);
 139                 new_size = dyn_getxattr(path, attr, buf, size);
 140
 141                 if(size == new_size)
 142                 {
 143                         buf[size] = '\0';
 144
 145                         if(len)
 146                                 *len=(int) size;
 147
 148                         return buf;
 149                 }
 150
 151                 g_free(buf);
 152         }
 153
 154         return NULL;
 155
 156 }
 157
 158 /* 0 on success */
 159 int xattr_set(const char *path, const char *attr,
 160               const char *value, int value_len)
 161 {
 162         if(o_xattr_ignore.int_value)
 163         {
 164                 errno = ENOSYS;
 165                 return 1;
 166         }
 167
 168         if (!dyn_setxattr)
 169         {
 170                 errno = ENOSYS;
 171                 return 1; /* Set attr failed */
 172         }
 173
 174         if(value && value_len<0)
 175                 value_len = strlen(value);
 176
 177         return dyn_setxattr(path, attr, value, value_len, 0);
 178 }
 179
 180
 181 #elif defined(HAVE_ATTROPEN)
 182
 183 /* Solaris 9 implementation */
 184
 185 void xattr_init(void)
 186 {
 187         option_add_int(&o_xattr_ignore, "xattr_ignore", FALSE);
 188 }
 189
 190 int xattr_supported(const char *path)
 191 {
 192         RETURN_IF_IGNORED(FALSE);
 193 #ifdef _PC_XATTR_ENABLED
 194         if(!path)
 195                 return TRUE;
 196
 197         return pathconf(path, _PC_XATTR_ENABLED);
 198 #else
 199         return FALSE;
 200 #endif
 201 }
 202
 203 int xattr_have(const char *path)
 204 {
 205         RETURN_IF_IGNORED(FALSE);
 206 #ifdef _PC_XATTR_EXISTS
 207         return pathconf(path, _PC_XATTR_EXISTS)>0;
 208 #else
 209         return FALSE;
 210 #endif
 211 }
 212
 213 #define MAX_ATTR_SIZE BUFSIZ
 214 gchar *xattr_get(const char *path, const char *attr, int *len)
 215 {
 216         int fd;
 217         char *buf=NULL;
 218         int nb;
 219
 220         RETURN_IF_IGNORED(NULL);
 221
 222 #ifdef _PC_XATTR_EXISTS
 223         if(!pathconf(path, _PC_XATTR_EXISTS))
 224                 return NULL;
 225 #endif
 226
 227         fd=attropen(path, attr, O_RDONLY);
 228
 229         if(fd>=0) {
 230                 buf = g_new(gchar, MAX_ATTR_SIZE);
 231                 nb=read(fd, buf, MAX_ATTR_SIZE);
 232                 if(nb>0) {
 233                         buf[nb]=0;
 234                 }
 235                 close(fd);
 236
 237                 if(len)
 238                         *len=nb;
 239         }
 240
 241         return buf;
 242 }
 243
 244 int xattr_set(const char *path, const char *attr,
 245               const char *value, int value_len)
 246 {
 247         int fd;
 248         int nb;
 249
 250         if(o_xattr_ignore.int_value)
 251         {
 252                 errno = ENOSYS;
 253                 return 1;
 254         }
 255
 256         if(value && value_len<0)
 257                 value_len = strlen(value);
 258
 259         fd=attropen(path, attr, O_WRONLY|O_CREAT, 0644);
 260         if(fd>0) {
 261
 262                 nb=write(fd, value, value_len);
 263                 if(nb==value_len)
 264                         ftruncate(fd, (off_t) nb);
 265
 266                 close(fd);
 267
 268                 if(nb>0)
 269                         return 0;
 270         }
 271
 272         return 1; /* Set type failed */
 273 }
 274
 275 #else
 276 /* No extended attributes available */
 277
 278 void xattr_init(void)
 279 {
 280 }
 281
 282 int xattr_supported(const char *path)
 283 {
 284         return FALSE;
 285 }
 286
 287 int xattr_have(const char *path)
 288 {
 289         return FALSE;
 290 }
 291
 292 gchar *xattr_get(const char *path, const char *attr, int *len)
 293 {
 294         /* Fall back to non-extended */
 295         return NULL;
 296 }
 297
 298 int xattr_set(const char *path, const char *attr,
 299               const char *value, int value_len)
 300 {
 301         errno = ENOSYS;
 302         return 1; /* Set type failed */
 303 }
 304
 305 #endif
 306
 307 MIME_type *xtype_get(const char *path)
 308 {
 309         MIME_type *type = NULL;
 310         gchar *buf;
 311         char *nl;
 312
 313         buf = xattr_get(path, XTYPE_ATTR, NULL);
 314
 315         if(buf)
 316         {
 317                 nl = strchr(buf, '\n');
 318                 if(nl)
 319                         *nl = 0;
 320                 type = mime_type_lookup(buf);
 321                 g_free(buf);
 322         }
 323         return type;
 324 }
 325
 326 int xtype_set(const char *path, const MIME_type *type)
 327 {
 328         int res;
 329         gchar *ttext;
 330
 331         if(o_xattr_ignore.int_value)
 332         {
 333                 errno = ENOSYS;
 334                 return 1;
 335         }
 336
 337         ttext = g_strdup_printf("%s/%s", type->media_type, type->subtype);
 338         res = xattr_set(path, XTYPE_ATTR, ttext, -1);
 339         g_free(ttext);
 340
 341         return res;
 342 }
 343