1편을 보지 않았다면 보고 오시는걸 추천합니다.
Remind
환경
일단 glibc 2.39 버전의 source code를 분석할 것이기 때문에 아래의 사이트에서 소스코드를 다운받았다.
glibc 분석을 진행하는 것이 처음이라 실수가 많을 수 있으며, 엉뚱한 이야기가 있을 수도 있습니다. 그 부분을 감안해서 너그러이 봐주시면 감사하겠습니다.
Example code
//gcc -o foepn fopen.c
#include <stdio.h>
int main(){
FILE *fp = 0;
fp = fopen("flag", "w");
fwrite("JANGJONGMIN", 1, 11, fp);
fclose(fp);
return 1;
}
C
복사
ASM
gef➤ disas main
Dump of assembler code for function main:
0x00005a2e23631189 <+0>: endbr64
0x00005a2e2363118d <+4>: push rbp
0x00005a2e2363118e <+5>: mov rbp,rsp
0x00005a2e23631191 <+8>: sub rsp,0x10
0x00005a2e23631195 <+12>: mov QWORD PTR [rbp-0x8],0x0
0x00005a2e2363119d <+20>: lea rax,[rip+0xe60] # 0x5a2e23632004
0x00005a2e236311a4 <+27>: mov rsi,rax
0x00005a2e236311a7 <+30>: lea rax,[rip+0xe58] # 0x5a2e23632006
0x00005a2e236311ae <+37>: mov rdi,rax
0x00005a2e236311b1 <+40>: call 0x5a2e23631080 <fopen@plt>
0x00005a2e236311b6 <+45>: mov QWORD PTR [rbp-0x8],rax
0x00005a2e236311ba <+49>: mov rax,QWORD PTR [rbp-0x8]
0x00005a2e236311be <+53>: mov rcx,rax
0x00005a2e236311c1 <+56>: mov edx,0xb
0x00005a2e236311c6 <+61>: mov esi,0x1
0x00005a2e236311cb <+66>: lea rax,[rip+0xe39] # 0x5a2e2363200b
0x00005a2e236311d2 <+73>: mov rdi,rax
0x00005a2e236311d5 <+76>: call 0x5a2e23631090 <fwrite@plt>
0x00005a2e236311da <+81>: mov rax,QWORD PTR [rbp-0x8]
0x00005a2e236311de <+85>: mov rdi,rax
0x00005a2e236311e1 <+88>: call 0x5a2e23631070 <fclose@plt>
0x00005a2e236311e6 <+93>: mov eax,0x1
0x00005a2e236311eb <+98>: leave
0x00005a2e236311ec <+99>: ret
End of assembler dump.
Assembly
복사
fopen Function
일단 먼저 stdio.h에 선언되어 있는 fopen 함수를 보면 아래와 같다.
fopen은 실제로 _IO_new_fopen 함수를 호출한다.
extern FILE *_IO_new_fopen (const char*, const char*);
# define fopen(fname, mode) _IO_new_fopen (fname, mode)
C
복사
_IO_new_fopen Function
_IO_new_fopen 함수에서 모든 인자를 __fopen_internal 전달하여 다시 함수를 호출한다.
FILE *
_IO_new_fopen (const char *filename, const char *mode)
{
return __fopen_internal (filename, mode, 1);
}
C
복사
__fopen_internal Function
*new_f 까지 분석하면 malloc을 통해서 (struct locked_FILE)의 구조체의 크기만큼 memory를 할당 한다.
FILE *
__fopen_internal (const char *filename, const char *mode, int is32)
{
struct locked_FILE
{
struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
struct _IO_wide_data wd;
} *new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
if (new_f == NULL)
return NULL;
#ifdef _IO_MTSAFE_IO
new_f->fp.file._lock = &new_f->lock;
#endif
_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps);
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps;
_IO_new_file_init_internal (&new_f->fp);
if (_IO_file_fopen ((FILE *) new_f, filename, mode, is32) != NULL)
return __fopen_maybe_mmap (&new_f->fp.file);
_IO_un_link (&new_f->fp);
free (new_f);
return NULL;
}
C
복사
일단 locked_FILE 구조체 먼저 보자
struct locked_FILE
해당 구조체는 fp, lock, wd로 이루어져 있다.
다른 구조체들도 같이 분석해보고 취합해보자.
struct locked_FILE
{
struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
struct _IO_wide_data wd;
}
C
복사
struct _IO_FILE_plus, _IO_jump_t
_IO_FILE_plus는 FILE 구조체와 _IO_jump_t를 가지고 있다.
_IO_jump_t의 구조체는 vtable의 구조를 가지고 있다. 다음 글에서 더 자세히 분석을 진행할 것이기 때문에 일단 대충 보고 넘어가면 된다.
struct _IO_FILE_plus
{
FILE file;
const struct _IO_jump_t *vtable;
};
struct _IO_jump_t
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
};
C
복사
struct _IO_lock_t
typedef struct { int lock; int cnt; void *owner; } _IO_lock_t;
C
복사
struct _IO_wide_data
/* Extra data for wide character streams. */
struct _IO_wide_data
{
wchar_t *_IO_read_ptr; /* Current read pointer */
wchar_t *_IO_read_end; /* End of get area. */
wchar_t *_IO_read_base; /* Start of putback+get area. */
wchar_t *_IO_write_base; /* Start of put area. */
wchar_t *_IO_write_ptr; /* Current put pointer. */
wchar_t *_IO_write_end; /* End of put area. */
wchar_t *_IO_buf_base; /* Start of reserve area. */
wchar_t *_IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
wchar_t *_IO_save_base; /* Pointer to start of non-current get area. */
wchar_t *_IO_backup_base; /* Pointer to first valid character of
backup area */
wchar_t *_IO_save_end; /* Pointer to end of non-current get area. */
__mbstate_t _IO_state;
__mbstate_t _IO_last_state;
struct _IO_codecvt _codecvt;
wchar_t _shortbuf[1];
const struct _IO_jump_t *_wide_vtable;
};
C
복사
•
__mbstate_t
typedef struct
{
int __count;
union
{
__WINT_TYPE__ __wch;
char __wchb[4];
} __value; /* Value so far. */
} __mbstate_t;
C
복사
struct locked_FILE 총정리
struct locked_FILE {
struct _IO_FILE_plus fp;
_IO_lock_t lock;
struct _IO_wide_data wd;
}
C
복사
fp와 wd는 사실상 거의 비슷하고, lock이 추가로 중간에 포함되어 있다.
즉 fopen에서 반환하는 값은 실제로는 FILE *가 아니라 locked_FILE *가 반환된다고 생각하면 된다.
fopen Debugging
fopen 실행전에 breakpoint를 걸고 si로 함수 내부에 진입한다.
malloc되는 값을 보면 0x1d8이다.
일단 malloc을 진행한 다음 ptype으로 보면 아래와 같이 출력된다.
p *(struct locked_FILE *)$rax
Bash
복사
확인해보면 메모리에 접근하여 값을 write 한 적이 없기 떄문에 Dummy 값이 들어가 있다.
$1 = {
fp = {
file = {
_flags = 0x0,
_IO_read_ptr = 0x0,
_IO_read_end = 0x0,
_IO_read_base = 0x0,
_IO_write_base = 0x0,
_IO_write_ptr = 0x0,
_IO_write_end = 0x0,
_IO_buf_base = 0x0,
_IO_buf_end = 0x0,
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x0,
_fileno = 0x0,
_flags2 = 0x0,
_old_offset = 0x0,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "",
_lock = 0x0,
_offset = 0x0,
_codecvt = 0x0,
_wide_data = 0x0,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0x0,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x0
},
lock = {
lock = 0x0,
cnt = 0x0,
owner = 0x0
},
wd = {
_IO_read_ptr = 0x0,
_IO_read_end = 0x0,
_IO_read_base = 0x0,
_IO_write_base = 0x0,
_IO_write_ptr = 0x0,
_IO_write_end = 0x0,
_IO_buf_base = 0x0,
_IO_buf_end = 0x0,
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_IO_state = {
__count = 0x0,
__value = {
__wch = 0x0,
__wchb = "\000\000\000"
}
},
_IO_last_state = {
__count = 0x0,
__value = {
__wch = 0x0,
__wchb = "\000\000\000"
}
},
_codecvt = {
__cd_in = {
step = 0x0,
step_data = {
__outbuf = 0x0,
__outbufend = 0x0,
__flags = 0x0,
__invocation_counter = 0x0,
__internal_use = 0x0,
__statep = 0x0,
__state = {
__count = 0x0,
__value = {
__wch = 0x0,
__wchb = "\000\000\000"
}
}
}
},
__cd_out = {
step = 0x0,
step_data = {
__outbuf = 0x0,
__outbufend = 0x0,
__flags = 0x0,
__invocation_counter = 0x0,
__internal_use = 0x0,
__statep = 0x0,
__state = {
__count = 0x0,
__value = {
__wch = 0x0,
__wchb = "\000\000\000"
}
}
}
}
},
_shortbuf = L"",
_wide_vtable = 0x0
}
}
Bash
복사
자 fopen 코드로 다시 돌아와서 설명을 진행해보면
FILE *
__fopen_internal (const char *filename, const char *mode, int is32)
{
...
*new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
if (new_f == NULL)
return NULL;
#ifdef _IO_MTSAFE_IO
new_f->fp.file._lock = &new_f->lock;
#endif
...
_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps);
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps;
_IO_new_file_init_internal (&new_f->fp);
if (_IO_file_fopen ((FILE *) new_f, filename, mode, is32) != NULL)
return __fopen_maybe_mmap (&new_f->fp.file);
...
}
C
복사
malloc을 통해서 구조체의 크기만큼 메모리르 할당 받는다. 만약 할당에 실패했으면 NULL을 반환하며, 성공했을 경우 멀티 스레드 환경에서 동일한 파일 스트림에 대해서 동시에 접근하지 못하도록 lock을 걸어준다.
이후 _IO_no_init, _IO_JUMPS, _IO_new_file_init_internal 함수를 호출하여 파일 구조체를 초기화 하고, _IO_file_fopen 함수를 이용하여 파일을 열고 이를 성공했다면 __fopen_maybe_mmap 함수를 통해서 메모리 매핑을 시도하고 파일 스트림을 반환한다.
_IO_on_init Function
_IO_old_init 함수를 먼저 분석해야 이후 과정을 이해할 수 있다.
일단 _IO_old_init 함수를 호출한다. 아래에서 해당 함수를 보겠다.
void
_IO_no_init (FILE *fp, int flags, int orientation,
struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
{
_IO_old_init (fp, flags);
fp->_mode = orientation;
if (orientation >= 0)
{
fp->_wide_data = wd;
fp->_wide_data->_IO_buf_base = NULL;
fp->_wide_data->_IO_buf_end = NULL;
fp->_wide_data->_IO_read_base = NULL;
fp->_wide_data->_IO_read_ptr = NULL;
fp->_wide_data->_IO_read_end = NULL;
fp->_wide_data->_IO_write_base = NULL;
fp->_wide_data->_IO_write_ptr = NULL;
fp->_wide_data->_IO_write_end = NULL;
fp->_wide_data->_IO_save_base = NULL;
fp->_wide_data->_IO_backup_base = NULL;
fp->_wide_data->_IO_save_end = NULL;
fp->_wide_data->_wide_vtable = jmp;
}
else
/* Cause predictable crash when a wide function is called on a byte
stream. */
fp->_wide_data = (struct _IO_wide_data *) -1L;
fp->_freeres_list = NULL;
}
C
복사
_IO_old_init 함수를 호출하는데 해당 함수를 보면 아래와 같다. orientation은 _IO_no_init 함수를 호출할 때 항상 0을 전달함으로, orientation은 0으로 설정된다고 보면 된다.
void
_IO_old_init (FILE *fp, int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_flags2 = 0;
if (stdio_needs_locking)
fp->_flags2 |= _IO_FLAGS2_NEED_LOCK;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;
fp->_IO_read_ptr = NULL;
fp->_IO_read_end = NULL;
fp->_IO_write_base = NULL;
fp->_IO_write_ptr = NULL;
fp->_IO_write_end = NULL;
fp->_chain = NULL; /* Not necessary. */
fp->_IO_save_base = NULL;
fp->_IO_backup_base = NULL;
fp->_IO_save_end = NULL;
fp->_markers = NULL;
fp->_cur_column = 0;
#if _IO_JUMPS_OFFSET
fp->_vtable_offset = 0;
#endif
#ifdef _IO_MTSAFE_IO
if (fp->_lock != NULL)
_IO_lock_init (*fp->_lock);
#endif
}
C
복사
fp→_flags에 IO_MAGIC과 인자로 전달받은 flags를 만들어주고 초기화 한다.
자 그럼 최종적으로 정리해보면 _IO_no_init 함수는 fp→flags, fp→_wide_data→_wdie_vtable의 값을 설정해주고 나머지는 초기화 한다고 볼 수 있다.
_IO_no_init 이전 fp
_IO_no_init 이후 fp
_IO_JUMPS Macro
_IO_no_init 함수 이후 실행하는 함수는 아래와 같다.
...
_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps);
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps;
_IO_new_file_init_internal (&new_f->fp);
...
C
복사
_IO_JUMPS 해당 매크로는 아래와 같다. vtable을 반환하는 코드다.
#define _IO_JUMPS(THIS) (THIS)->vtable
C
복사
디버깅으로 확인해보면 아래와 같이 변경된다.
gef➤ p (struct locked_FILE*)new_f->fp->vtable
$1 = (const struct _IO_jump_t *) 0x0
gef➤ si 3
gef➤ si
gef➤ p (struct locked_FILE*)new_f->fp->vtable
$2 = (struct locked_FILE *) 0x7db825c02030 <_IO_file_jumps>
C
복사
_IO_new_file_init_internal Function
다음으로 실행하는 _IO_new_file_init_internal 함수에 대해서 분석해보자
코드는 아래와 같다.
_offset을 설정하고 flags를 CLOSED_FILEBUF_FLAGS로 변경해주고 _IO_link_in 함수를 호출한다.
void
_IO_new_file_init_internal (struct _IO_FILE_plus *fp)
{
/* POSIX.1 allows another file handle to be used to change the position
of our file descriptor. Hence we actually don't know the actual
position before we do the first fseek (and until a following fflush). */
fp->file._offset = _IO_pos_BAD;
fp->file._flags |= CLOSED_FILEBUF_FLAGS;
_IO_link_in (fp);
fp->file._fileno = -1;
}
C
복사
_IO_link_in Function
void
_IO_link_in (struct _IO_FILE_plus *fp)
{
if ((fp->file._flags & _IO_LINKED) == 0)
{
fp->file._flags |= _IO_LINKED;
#ifdef _IO_MTSAFE_IO
_IO_cleanup_region_start_noarg (flush_cleanup);
_IO_lock_lock (list_all_lock);
run_fp = (FILE *) fp;
_IO_flockfile ((FILE *) fp);
#endif
fp->file._chain = (FILE *) _IO_list_all;
_IO_list_all = fp;
#ifdef _IO_MTSAFE_IO
_IO_funlockfile ((FILE *) fp);
run_fp = NULL;
_IO_lock_unlock (list_all_lock);
_IO_cleanup_region_end (0);
#endif
}
}
libc_hidden_def (_IO_link_in)
C
복사
_flags를 검사하여 _IO_LINKED 되어있지 않다면(링크되어 있지 않다면) _IO_LINKED 플레그를 설정하고 #ifdef _IO_MTSAFE_IO 부분은 멀티스레드 안정성을 위한 처리를 진행한다.
파일 스트림을 전역 파일 스트림 목록인 _IO_list_all에 추가한 뒤, _chain 포인터를 _IO_list_all이 가르키는 스트림으로 연결하고 _IO_list_all을 업데이트한다.
실제로 저렇게 작동하는지 확인해보기 위해서 해당 함수전과 후의 _IO_list_all, _chain을 보면 아래와 같다.
_IO_new_file_init_internal 전
_IO_new_file_init_internal 후
마지막으로 _IO_file_fopen, __fopen_maybe_mmap 함수만 보면 끝이다.
_IO_file_fopen Function
함수가 많이 길어 필요한 부분만 따서 보자
_IO_new_file_fopen Code
...
if (_IO_file_is_open (fp)) //fileops.c
return 0;
switch (*mode)
{
...
#define _IO_file_is_open(__fp) ((__fp)->_fileno != -1) //libioP.h
C
복사
_IO_file_is_open는 파일이 열려있는지 확인한 뒤, 열여있지 않다면 return 0를 아니라면 mode로 전달받은 인자에 맞게 switch문에서 flags를 설정한 뒤 _IO_file_open 함수를 호출한다.
result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
is32not64);
C
복사
_IO_file_oepn Function
일단 __open 먼저 따라가보자
FILE *
_IO_file_open (FILE *fp, const char *filename, int posix_mode, int prot,
int read_write, int is32not64)
{
int fdesc;
if (__glibc_unlikely (fp->_flags2 & _IO_FLAGS2_NOTCANCEL))
fdesc = __open_nocancel (filename,
posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
else
fdesc = __open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
if (fdesc < 0)
return NULL;
fp->_fileno = fdesc;
_IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
/* For append mode, send the file offset to the end of the file. Don't
update the offset cache though, since the file handle is not active. */
if ((read_write & (_IO_IS_APPENDING | _IO_NO_READS))
== (_IO_IS_APPENDING | _IO_NO_READS))
{
off64_t new_pos = _IO_SYSSEEK (fp, 0, _IO_seek_end);
if (new_pos == _IO_pos_BAD && errno != ESPIPE)
{
__close_nocancel (fdesc);
return NULL;
}
}
_IO_link_in ((struct _IO_FILE_plus *) fp);
return fp;
}
libc_hidden_def (_IO_file_open)
C
복사
__open Function
__open은 내부적으로 __libc_open64를 호출한다. 해당 함수는 SYSCALL을 이용해서 파일을 열어 fd를 반환한다.
/* Open FILE with access OFLAG. If O_CREAT or O_TMPFILE is in OFLAG,
a third argument is the file protection. */
int
__libc_open64 (const char *file, int oflag, ...)
{
int mode = 0;
if (__OPEN_NEEDS_MODE (oflag))
{
va_list arg;
va_start (arg, oflag);
mode = va_arg (arg, int);
va_end (arg);
}
return SYSCALL_CANCEL (openat, AT_FDCWD, file, oflag | O_LARGEFILE,
mode);
}
strong_alias (__libc_open64, __open64)
libc_hidden_weak (__open64)
weak_alias (__libc_open64, open64)
#ifdef __OFF_T_MATCHES_OFF64_T
strong_alias (__libc_open64, __libc_open)
strong_alias (__libc_open64, __open)
libc_hidden_weak (__open)
weak_alias (__libc_open64, open)
#endif
C
복사
최종적으로 return되는 fd는 fdesc에 들어가있고 fp→_fileno에 넣어준다.
...
fp->_fileno = fdesc;
_IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
...
C
복사
_IO_mask_flags Macro
그냥 flag 마스킹해주는 매크로다
#define _IO_mask_flags(fp, f, mask) \
((fp)->_flags = ((fp)->_flags & ~(mask)) | ((f) & (mask)))
C
복사
마지막으로 _IO_link_in 함수를 실행하고 fp를 리턴한다. 해당 함수는 위에서 분석을 진행했었다. 다시 한번 상기해보자
파일 스트림을 전역 파일 스트림 목록인 _IO_list_all에 추가한 뒤, _chain 포인터를 _IO_list_all이 가르키는 스트림으로 연결하고 _IO_list_all을 업데이트한다.
...
_IO_link_in ((struct _IO_FILE_plus *) fp);
return fp;
C
복사
다시 이제 _IO_new_file_fopen 함수로 돌아오자 최종적으로 result에 담기는 값은 전달한 fp이며, 해당 fp→_fileno에 syscall을 이용하여 할당 받은 descriptor을 설정해준다.
result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
is32not64);
if (result != NULL)
{
/* Test whether the mode string specifies the conversion. */
cs = strstr (last_recognized + 1, ",ccs=");
C
복사
파일이름에 ,css=가 들어가있는지 확인하고 없다면 result를 return 한다.
마지막으로 __fopen_maybe_mmap 함수를 분석하면 끝이다.
if (_IO_file_fopen ((FILE *) new_f, filename, mode, is32) != NULL)
return __fopen_maybe_mmap (&new_f->fp.file);
C
복사
__fopen_maybe_mmap
FILE *
__fopen_maybe_mmap (FILE *fp)
{
#if _G_HAVE_MMAP
if ((fp->_flags2 & _IO_FLAGS2_MMAP) && (fp->_flags & _IO_NO_WRITES))
{
/* Since this is read-only, we might be able to mmap the contents
directly. We delay the decision until the first read attempt by
giving it a jump table containing functions that choose mmap or
vanilla file operations and reset the jump table accordingly. */
if (fp->_mode <= 0)
_IO_JUMPS_FILE_plus (fp) = &_IO_file_jumps_maybe_mmap;
else
_IO_JUMPS_FILE_plus (fp) = &_IO_wfile_jumps_maybe_mmap;
fp->_wide_data->_wide_vtable = &_IO_wfile_jumps_maybe_mmap;
}
#endif
return fp;
}
C
복사
flag를 확인한 다음 연산을 수행하지만, 테스트 코드에서는 if문 안으로 들어가지 않으니 넘어가겠다.
마지막 정리
이제 진짜 끝이다. 함수의 호출 순서 및 기능을 알아봤으니 fopen을 간단하게 정리해보면 아래와 같다.
1.
fopen 호출시 locked_FILE 구조체를 기반으로 메모리를 할당
2.
할당 된 메모리에 해당 구조체 초기화
3.
해당 구조체에 vtable 설정, flags 설정
4.
전역 파일 스트림 목록 업데이트
5.
open system call을 통해서 실제 파일을 열고 mode를 확인하여 flags 설정
6.
_IO_FILE_plus에 맞게 구체를 다 할당해줬다면, 해당 file descriptor를 반환
자 그럼 일단 마지막 return 되는 부분을 살펴보자 일단 return 되는 타입은 FILE *이다.
return __fopen_maybe_mmap (&new_f->fp.file);
C
복사
결론적으로 return은 &new_f의 fp.file이 리턴이 된다.
fp를 다시 한번 살펴보면 아래와 같이 선언되어 있다.
struct _IO_FILE_plus fp;
C
복사
자 일단 fopen 분석은 끝이다.
다음 글로 해당 _IO_FILE_plus 구조체를 다시 분석하면서 어떤 값이 들어가있는지 보겠다.
