/rusxmms/librcc

To get this branch, use:
bzr branch http://suren.me/webbzr/rusxmms/librcc

« back to all changes in this revision

Viewing changes to src/fs.c

  • Committer: Suren A. Chilingaryan
  • Date: 2005-06-16 23:14:30 UTC
  • Revision ID: Arch-1:ds@dside.dyndns.org--darksoft-2004%librcc--main--0.1--base-0
Initial Import

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/fs.c
 
1
#include <stdio.h>
 
2
#include <errno.h>
 
3
#include <unistd.h>
 
4
#include <sys/types.h>
 
5
#include <sys/stat.h>
 
6
#include <mntent.h>
 
7
 
 
8
#include "librcc.h"
 
9
 
 
10
static char *rccCreateFullName(const char *path, const char *filename) {
 
11
    unsigned int i;
 
12
    char *name;
 
13
        
 
14
    if (!path) {
 
15
        if (filename) return strdup(filename);
 
16
        else return strdup("/");
 
17
    } else if (!filename) return strdup(path);
 
18
    
 
19
    
 
20
    i = strlen(path);
 
21
    name = (char*)malloc(i+strlen(filename)+2)*sizeof(char));
 
22
    if (!name) return NULL;
 
23
    
 
24
    if ((path[i-1]=='/')||(filename[0]=='/'))
 
25
        sprintf(name, "%s%s", path, filename);
 
26
    else
 
27
        sprintf(name, "%s/%s", path, filename);
 
28
 
 
29
    return name;
 
30
}
 
31
 
 
32
static int rccIsFile(const char *filename) {
 
33
    struct stat st;
 
34
 
 
35
    stat(filename,&st);
 
36
    if (S_ISREG(st.st_mode)) return 1;
 
37
    return 0;
 
38
}
 
39
 
 
40
static char *rccCheckFile(const char *prefix, const char *name) {
 
41
    char *temp;
 
42
    
 
43
    temp = rccCreateFullName(prefix, name);
 
44
    if ((!temp)||(rccIsFile(temp))) return temp;
 
45
 
 
46
    free(temp);
 
47
    return NULL;
 
48
}
 
49
 
 
50
int rccFS0(const char *fspath, const char *filename, char **prefix, char **name) {
 
51
    FILE *mtab;
 
52
    struct mntent *fsentry;
 
53
    char *tmp;
 
54
 
 
55
    if (fspath) {
 
56
        tmp = strstr(filename, fspath);
 
57
        if (tmp) tmp = filename + strlen(fspath);
 
58
    } else {
 
59
        mtab = setmntent(_PATH_MNTTAB, "r");
 
60
        if (mtab) {
 
61
            while (!feof(mtab)) {
 
62
                fsentry = getmntent(mtab);
 
63
                if ((fsentry)&&(fsentry->mnt_dir)) {
 
64
                    tmp = strstr(filename, fsentry->mnt_dir);
 
65
                    if (tmp) tmp = filename + strlen(fsentry->mnt_dir);
 
66
                }
 
67
            }
 
68
            endmntent(mtab);
 
69
        }
 
70
    }
 
71
 
 
72
    if (!tmp) tmp = filename;
 
73
 
 
74
    *name = strdup(tmp);
 
75
    *prefix = strndup(filename, (tmp-filename));
 
76
 
 
77
    if ((!*name)||(!*prefix)) {
 
78
        if (*name) free(*name);
 
79
        if (*prefix) free(*prefix);
 
80
        return -1;    
 
81
    }
 
82
 
 
83
    return 0;
 
84
}
 
85
 
 
86
int rccFS1(rcc_context *ctx, const char *fspath, char **prefix, char **name) {
 
87
    int prefix_size;
 
88
    char *result, *tmp;
 
89
    char *path, *filename;
 
90
    
 
91
    path = *prefix;
 
92
    filename = *name;
 
93
    
 
94
 
 
95
    if ((path)&&(filename)) {
 
96
        result = rccCreateFullName(path, filename);
 
97
        if (!result) return -1;
 
98
    } else if (filename) result = filename;
 
99
    else if (path) result = path;
 
100
    else return -1;
 
101
    
 
102
    
 
103
        // Checking without recoding in case of autodetection
 
104
    if (rccGetOption(ctx, RCC_AUTODETECT_FS_NAMES)) {
 
105
        if (rccIsFile(name)) {
 
106
            if ((path)&&(filename)) *name = result;
 
107
            else if (filename) *name = strdup(filename);
 
108
            else *name = strdup(path);
 
109
            return 1;
 
110
        }
 
111
    }
 
112
 
 
113
    err = rccFS0(fspath, result, &prefix, &name);
 
114
    if ((path)&&(filename)) free(name);
 
115
    
 
116
    return err;    
 
117
}
 
118
 
 
119
char *rccFS2(rcc_context *ctx, iconv_t icnv, const char *prefix, const char *name) {
 
120
    if (icnv == (iconv_t)-1) return NULL;
 
121
    if (icnv == (iconv_t)-2) {
 
122
        strcpy(ctx->tmpbuffer, name);
 
123
        ctx->tmpbuffer[len] = 0;
 
124
    } else {
 
125
        err = rccIConv(ctx, icnv, name, 0);
 
126
        if (err<=0) return NULL;
 
127
    }
 
128
 
 
129
    return rccCheckFile(prefix, ctx->tmpbuffer);
 
130
}
 
131
 
 
132
char *rccFS3(rcc_context *ctx, rcc_language_id language_id, rcc_class_id class_id, const char *prefix, const char *name) {
 
133
    rcc_charset charset; 
 
134
    rcc_language *language;
 
135
    iconv_t icnv = ctx->fsiconv;
 
136
 
 
137
    if ((rccGetOption(ctx, RCC_AUTODETECT_FS_NAMES))&&(icnv != (iconv_t)-1)) {
 
138
        result = rccFS2(ctx, icnv, prefix, name);
 
139
        if (result) return result;
 
140
    }
 
141
    
 
142
    result = rccFS2(ctx, ctx->iconv_to[class_id], prefix, name);
 
143
    if (result) {
 
144
        if ((icnv != (iconv_t)-1)||(icnv != (iconv_t)-2))  iconv_close(icnv);
 
145
        ctx->fsiconv = (iconv_t)-1;
 
146
        return result;
 
147
    }
 
148
 
 
149
    if (rccGetOption(ctx, RCC_AUTODETECT_FS_NAMES)) {
 
150
        language = ctx->language[language_id];
 
151
        if (language->charset[0]) {
 
152
            for (i=1;(!result);i++) {
 
153
                charset = language->charsets[i];
 
154
                if (!charset) break;
 
155
                
 
156
                if ((icnv != (iconv_t)-1)&&(icnv != (iconv_t)-2)) iconv_close(icnv);
 
157
 
 
158
                if (strcmp(charset, "UTF-8")&&strcmp(charset, "UTF8")) icnv = (iconv_t)-2;
 
159
                else icnv = iconv_open(charset, "UTF-8");
 
160
                
 
161
                result = rccFS2(ctx, icnv, prefix, name);
 
162
            }
 
163
        }
 
164
    }
 
165
    if (result) ctx->fsiconv = icnv;
 
166
    else {
 
167
        if ((icnv != (iconv_t)-1)&&(icnv != (iconv_t)-2)) iconv_close(icnv);
 
168
        ctx->fsiconv = (iconv_t)-1;
 
169
    }
 
170
    
 
171
    return result;
 
172
}