File: chroot.cpp

package info (click to toggle)
fakeroot-ng 0.12-3
  • links: PTS
  • area: main
  • in suites: lenny
  • size: 1,828 kB
  • ctags: 552
  • sloc: sh: 9,156; cpp: 3,186; ansic: 1,295; makefile: 132
file content (314 lines) | stat: -rw-r--r-- 10,975 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
/*
    Fakeroot Next Generation - run command with fake root privileges
    This program is copyrighted. Copyright information is available at the
    AUTHORS file at the root of the source tree for the fakeroot-ng project

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#include "config.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>

#include <assert.h>
#include <limits.h>
#include <string.h>

#include "syscalls.h"
#include "parent.h"
#include "chroot.h"

// These are the Linux kernel parameters
static const int GLOBAL_LINKS=40, // How many links are globally allowed in the dir part of the resolution
    LOCAL_LINKS=8, // How many links each directory level is allowed to have nested
    LAST_MILE_LINKS=32; // How many links are allowed in the file part of the link

bool chroot_is_chrooted( const pid_state *state )
{
    return state->root!="" && state->root!="/";
}

// XXX The memory efficiency of the implementation can use a DRASTIC improvement
static std::string chroot_parse_path_recursion( const pid_state *state, char *path, const std::string &wd, struct stat *stat,
    int &global_link_count, int dir_link_count, bool resolve_links )
{
    std::string partial_path;
    
    // Body of function - find out the last path component position
    int last_slash=-1;
    for( int i=0; path[i]!='\0'; ++i )
        if( path[i]=='/' )
            last_slash=i;

    std::string file_part( path+last_slash+1 );

    // Remove redundant slashes
    while( last_slash>0 && path[last_slash-1]=='/' )
        last_slash--;

    std::string dir_part;

    if( last_slash>0 ) {
        // A slash appears in the file name, and it is not the first character
        
        path[last_slash]='\0'; // Chop off the file part
        dir_part=chroot_parse_path_recursion( state, path, wd, stat, global_link_count, LOCAL_LINKS, true ); // Translate the rest of the path

        if( (int)stat->st_ino==-1 ) {
            // Pass the error on - no further processing
            return dir_part+"/"+file_part;
        }
    } else if( last_slash==0 ) {
        // Need to process the leading slash
        dir_part=state->root;
    } else {
        // A file part is all we have to begin with - see what the we are relative to
        dir_part=wd;
    }

    // At this point we have the leading directory in our (debugger) context, and the file part in debugee context
    if( file_part=="." || file_part=="" ) {
        // Same directory - do nothing more
        return dir_part;
    }

    if( file_part==".." ) {
        // We need to go one directory up. This is not as simple as it sounds

        // Are we currently at the root (either real or jail)?
        if( dir_part==state->root || dir_part=="/" ) {
            // Going up is the same as staying at the same place
            return dir_part;
        }

        // Again - find the last slash in the string, and strip everything after it
        size_t last=dir_part.rfind('/');

        if( last==std::string::npos ) {
            dlog("chroot_parse_path: dir part \"%s\" with file part \"..\" has no way to go one up\n", dir_part.c_str());
            dlog(NULL);

            assert( last!=std::string::npos );
        }

        // Eliminate repeats
        while( last>0 && dir_part[last-1]=='/' )
            last--;

        if( last==0 ) // Leave one slash in place if that's all there is
            last++;

        return dir_part.substr(0, last);
    }

    // We now, finally, have an honest to god, non empty, non special, file part to handle
    std::string combined_path=dir_part+"/"+file_part;
    if( lstat( combined_path.c_str(), stat )==-1 ) {
        // We failed to stat the file. Just bounce the error to the caller
        stat->st_ino=-1;
        return combined_path;
    }

    // Is this a symbolic link?
    while( resolve_links && dir_link_count>0 && S_ISLNK(stat->st_mode) ) {
        if( (dir_link_count--)==0 || (global_link_count--)==0 ) {
            // We are out of patience for link processing
            errno=ELOOP;
            stat->st_ino=-1;
            return "";
        }

        char buffer[PATH_MAX+1];

        ssize_t link_len=readlink( combined_path.c_str(), buffer, sizeof(buffer) );

        if( link_len==-1 ) {
            dlog("chroot_parse_path_recursion: lstat succeeded for %s, but readlink failed: %s\n", combined_path.c_str(),
                strerror(errno) );

            return combined_path;
        }

        if( link_len==sizeof(buffer) ) {
            // Symbolic link's content is too long
            errno=ENAMETOOLONG;
            stat->st_ino=-1;

            return "";
        }

        buffer[link_len]='\0';

        if( strchr( buffer, '/' )==NULL ) {
            // The / character does not appear - just replace file_part with the new version
            file_part=buffer;
            combined_path=dir_part+"/"+file_part;
            if( lstat( combined_path.c_str(), stat )==-1 ) {
                // We failed to stat the file. Just bounce the error to the caller
                stat->st_ino=-1;
                return combined_path;
            }
        } else {
            // The symlink is a complex path - use ourselves recursively to figure out where it actually links to
            return chroot_parse_path_recursion( state, buffer, dir_part, stat, global_link_count, dir_link_count, false );
        }
    }

    return combined_path;
}

// Actual implementation - some sanity checking, and then call the recursive version
std::string chroot_parse_path( const pid_state *state, char *path, const std::string &wd, struct stat *stat, bool resolve_last_link )
{
    stat->st_ino=-2; // Mark this as a no-op. If we later do run a stat, it will be overridden

    if( path==NULL || path[0]=='\0' ) {
        stat->st_ino=-1;
        errno=ENOENT;
        return "";
    }

    int total_links=GLOBAL_LINKS;

    if( log_level==0 )
        return chroot_parse_path_recursion( state, path, wd, stat, total_links, LAST_MILE_LINKS, resolve_last_link );
    else {
        dlog("chroot_parse_path: translating %s with work dir of %s\n", path, wd.c_str());

        std::string ret=chroot_parse_path_recursion( state, path, wd, stat, total_links, LAST_MILE_LINKS, resolve_last_link );
        dlog("chroot_parse_path: translated path is %s\n", ret.c_str() );

        return ret;
    }
}

std::string chroot_translate_addr( pid_t pid, const pid_state *state, struct stat *stat, int dirfd, void *addr, bool resolve_last_link )
{
    char filename[PATH_MAX], wd[PATH_MAX];
    ptlib_get_string( pid, addr, filename, sizeof(filename) );

    strcpy( wd, "/" );

    // Get the process' working dir
    if( dirfd==CHROOT_PWD )
        ptlib_get_cwd( pid, wd, sizeof(wd) );
    else
        ptlib_get_fd( pid, dirfd, wd, sizeof(wd) );

    return chroot_parse_path( state, filename, wd, stat, resolve_last_link );
}

bool chroot_translate_param( pid_t pid, const pid_state *state, int param_num, bool resolve_last_link, bool abort_error, int_ptr offset )
{
    return chroot_translate_paramat( pid, state, CHROOT_PWD, param_num, resolve_last_link, abort_error, offset );
}

// Same as chroot_translate_param, only for the *at family of functions
bool chroot_translate_paramat( pid_t pid, const pid_state *state, int dirfd, int param_num, bool resolve_last_link,
    bool abort_error, int_ptr offset )
{
    // Short path if we are not chrooted
    if( !chroot_is_chrooted(state) )
        return true;

    void *path_addr=(void *)ptlib_get_argument( pid, param_num );
    if( path_addr==NULL ) {
        // The process asked to work directly on the file descriptor - do not touch the path
        return true;
    }

    struct stat stat;

    std::string newpath=chroot_translate_addr( pid, state, &stat, dirfd, path_addr, resolve_last_link );

    if( stat.st_ino!=(ino_t)-1 || !abort_error ) {
        strcpy( state->shared_mem_local.getc()+offset, newpath.c_str() );
        ptlib_set_argument( pid, param_num, ((int_ptr)state->shared_memory)+offset );
    }

    return stat.st_ino!=(ino_t)-1;
}

bool sys_chroot( int sc_num, pid_t pid, pid_state *state )
{
    if( state->state==pid_state::NONE ) {
        // Save the path pointer and NOP the call
        state->context_state[0]=ptlib_get_argument( pid, 1 );
        state->state=pid_state::REDIRECT2;
        ptlib_set_syscall( pid, PREF_NOP );
    } else if( state->state==pid_state::REDIRECT2 ) {
        // We may already be chrooted - need to translate the path
        struct stat stat;
        std::string newroot=chroot_translate_addr( pid, state, &stat, CHROOT_PWD, (void *)state->context_state[0], true );

        if( (int)stat.st_ino!=-1 ) {
            // The call succeeded
            state->root=newroot;
            ptlib_set_retval( pid, 0 ); // Success returns 0
        } else {
            // The call failed
            ptlib_set_error( pid, sc_num, errno );
        }

        state->state=pid_state::NONE;
    }

    return true;
}

// This function handles the generic case where the function is one that does not need fake root
// special handling, except we need to translate the first parameter in case we are chrooted
bool sys_generic_chroot_support_param1( int sc_num, pid_t pid, pid_state *state )
{
    if( state->state==pid_state::NONE ) {
        state->state=pid_state::RETURN;

        chroot_translate_param( pid, state, 1, true );
    } else if( state->state==pid_state::RETURN ) {
        state->state=pid_state::NONE;
    }

    return true;
}

// Same as above, only when the last link is not resolved
bool sys_generic_chroot_support_link_param1( int sc_num, pid_t pid, pid_state *state )
{
    if( state->state==pid_state::NONE ) {
        state->state=pid_state::RETURN;

        chroot_translate_param( pid, state, 1, false );
    } else if( state->state==pid_state::RETURN ) {
        state->state=pid_state::NONE;
    }

    return true;
}

bool sys_generic_chroot_support_param2( int sc_num, pid_t pid, pid_state *state )
{
    if( state->state==pid_state::NONE ) {
        state->state=pid_state::RETURN;

        chroot_translate_param( pid, state, 2, true );
    } else if( state->state==pid_state::RETURN ) {
        state->state=pid_state::NONE;
    }

    return true;
}