probe_file/da_io_stdc.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Jaewon Lim <jaewon81.lim@samsung.com>
   9  * Woojin Jung <woojin2.jung@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  * Anastasia Lyupa <a.lyupa@samsung.com>
  12  *
  13  * This library is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the
  15  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  21  * License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  25  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  * - Samsung RnD Institute Russia
  30  *
  31  */
  32
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <dlfcn.h>
  38 #include <errno.h>
  39 #include "daprobe.h"
  40 #include "probeinfo.h"
  41 #include "dautil.h"
  42 #include "dahelper.h"
  43 #include "da_io.h"
  44
  45 #include "binproto.h"
  46
  47 static enum DaOptions _sopt = OPT_FILE;
  48
  49 FILE* fopen(const char* filename, const char* mode)
  50 {
  51         static FILE* (*fopenp)(const char* filename, const char* mode);
  52         FILE* fret;
  53
  54         BEFORE_ORIGINAL_FILE_NOFILTER(fopen, LIBC);
  55         _filepath = (char*)filename;
  56
  57         fret = fopenp(filename, mode);
  58
  59         AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "ss", filename, mode);
  60
  61         return fret;
  62 }
  63
  64 FILE* freopen(const char * filename, const char * mode, FILE * stream)
  65 {
  66         static FILE* (*freopenp)(const char * filename, const char * mode, FILE * stream);
  67         FILE* fret;
  68
  69         BEFORE_ORIGINAL_FILE_NOFILTER(freopen, LIBC);
  70         _filepath = (char*)filename;
  71
  72         fret = freopenp(filename, mode, stream);
  73
  74         AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "ssp", filename, mode, stream);
  75
  76         return fret;
  77 }
  78
  79 FILE* fdopen(int fildes, const char *mode)
  80 {
  81         static FILE* (*fdopenp)(int fildes, const char *mode);
  82         FILE* fret;
  83
  84         BEFORE_ORIGINAL_FILE_NOFILTER(fdopen, LIBC);
  85
  86         fret = fdopenp(fildes, mode);
  87
  88         AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "ds", fildes, mode);
  89
  90         return fret;
  91 }
  92
  93 int fflush(FILE* stream)
  94 {
  95         static int (*fflushp)(FILE* stream);
  96
  97         BEFORE_ORIGINAL_FILE(fflush, LIBC);
  98         ret = fflushp(stream);
  99         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
 100         return ret;
 101 }
 102
 103 int fclose(FILE* stream)
 104 {
 105         static int (*fclosep)(FILE* stream);
 106         DECLARE_VARIABLE_FD;
 107
 108         GET_REAL_FUNC(fclose, LIBC);
 109
 110         bfiltering = false;
 111         PRE_PROBEBLOCK_BEGIN();
 112         GET_FD_FROM_FILEP(stream);
 113         if(_fd != -1) {
 114                 _fstatret = fstat(_fd, &_statbuf);
 115         }
 116         PRE_PROBEBLOCK_END();
 117
 118         ret = fclosep(stream);
 119
 120         POST_PACK_PROBEBLOCK_BEGIN();
 121         PREPARE_LOCAL_BUF();
 122         PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, LC_RESOURCE, "p", stream);
 123         PACK_COMMON_END(ret, newerrno, blockresult);
 124         POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
 125         POST_PACK_PROBEBLOCK_END();
 126
 127         return ret;
 128 }
 129
 130 int remove(const char* filename)
 131 {
 132         static int (*removep)(const char* filename);
 133
 134         BEFORE_ORIGINAL_FILE(remove, LIBC);
 135         _filepath = (char*)filename;
 136         ret = removep(filename);
 137         AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "s", filename);
 138         return ret;
 139 }
 140
 141 int rename(const char* oldname, const char* newname)
 142 {
 143         static int (*renamep)(const char* oldname, const char* newname);
 144
 145         BEFORE_ORIGINAL_FILE(rename, LIBC);
 146         _filepath = (char*)newname;
 147         ret = renamep(oldname, newname);
 148         AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "ss", oldname, newname);
 149         return ret;
 150 }
 151
 152 FILE * tmpfile ( void )
 153 {
 154         static FILE* (*tmpfilep) ( void );
 155         FILE* fret;
 156
 157         BEFORE_ORIGINAL_FILE_NOFILTER(tmpfile, LIBC);
 158         _filepath = "<temp file>";
 159         fret = tmpfilep();
 160         AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "s", "");
 161         return fret;
 162 }
 163
 164 int fgetpos(FILE* stream, fpos_t* position)
 165 {
 166         static int (*fgetposp)(FILE* stream, fpos_t* position);
 167
 168         BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
 169         ret = fgetposp(stream, position);
 170         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "pp", stream, position);
 171         return ret;
 172 }
 173
 174 int fseek(FILE* stream, long int offset, int origin)
 175 {
 176         static int (*fseekp)(FILE* stream, long int offset, int origin);
 177
 178         BEFORE_ORIGINAL_FILE(fseek, LIBC);
 179         ret = fseekp(stream, offset, origin);
 180         AFTER_PACK_ORIGINAL_FILEP(ret, (unsigned int)offset, stream, FD_API_OTHER,
 181                         "pxd", stream, offset, origin);
 182         return ret;
 183 }
 184
 185 int fsetpos(FILE* stream, const fpos_t* pos)
 186 {
 187         static int (*fsetposp)(FILE* stream, const fpos_t* pos);
 188
 189         BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
 190         ret = fsetposp(stream, pos);
 191         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "pp", stream, pos);
 192         return ret;
 193 }
 194
 195 long int ftell(FILE* stream)
 196 {
 197         static long int (*ftellp)(FILE* stream);
 198         long int lret;
 199
 200         BEFORE_ORIGINAL_FILE(ftell, LIBC);
 201
 202         lret = ftellp(stream);
 203
 204         AFTER_PACK_ORIGINAL_FILEP(lret, 0, stream, FD_API_OTHER, "p", stream);
 205
 206         return lret;
 207 }
 208
 209 void rewind(FILE* stream)
 210 {
 211         static void (*rewindp)(FILE* stream);
 212
 213         BEFORE_ORIGINAL_FILE(rewind, LIBC);
 214
 215         rewindp(stream);
 216
 217         AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "p", stream);
 218 }
 219
 220 void clearerr(FILE* stream)
 221 {
 222         static void (*clearerrp)(FILE* stream);
 223
 224         BEFORE_ORIGINAL_FILE(clearerr, LIBC);
 225
 226         clearerrp(stream);
 227
 228         AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "p", stream);
 229 }
 230
 231 int feof(FILE* stream)
 232 {
 233         static int (*feofp)(FILE* stream);
 234
 235         BEFORE_ORIGINAL_FILE(feof, LIBC);
 236         ret = feofp(stream);
 237         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
 238         return ret;
 239 }
 240
 241 int ferror(FILE* stream)
 242 {
 243         static int (*ferrorp)(FILE* stream);
 244
 245         BEFORE_ORIGINAL_FILE(ferror, LIBC);
 246         ret = ferrorp(stream);
 247         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
 248         return ret;
 249 }
 250
 251 int fileno(FILE* stream)
 252 {
 253         static int (*filenop)(FILE* stream);
 254
 255         BEFORE_ORIGINAL_FILE(fileno, LIBC);
 256         ret = filenop(stream);
 257         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
 258         return ret;
 259 }
 260
 261 void perror(const char* string)
 262 {
 263         static void (*perrorp)(const char* string);
 264
 265         BEFORE_ORIGINAL_FILE(perror, LIBC);
 266
 267         perrorp(string);
 268
 269         AFTER_PACK_ORIGINAL_NOFD(0, 0, FD_API_OTHER, "s", string);
 270 }
 271
 272 // *******************************************************************
 273 // File read / write APIs
 274 // *******************************************************************
 275
 276 int vfprintf(FILE* stream, const char* format, va_list arg)
 277 {
 278         static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
 279
 280         BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
 281         ret = vfprintfp(stream, format, arg);
 282         AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_WRITE, "ps", stream, format);
 283         return ret;
 284 }
 285
 286 int vfscanf(FILE* stream, const char* format, va_list arg)
 287 {
 288         static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
 289
 290         BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
 291         ret = vfscanfp(stream, format, arg);
 292         AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_READ, "ps", stream, format);
 293         return ret;
 294 }
 295
 296 int fgetc(FILE* stream)
 297 {
 298         static int (*fgetcp)(FILE* stream);
 299
 300         BEFORE_ORIGINAL_FILE(fgetc, LIBC);
 301         ret = fgetcp(stream);
 302         AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_READ, "p", stream);
 303         return ret;
 304 }
 305
 306 #if 0   // why is this commented?
 307 char* fgets(char* str, int size, FILE* stream)
 308 {
 309         static char* (*fgetsp)(char* str, int num, FILE* stream);
 310         char* cret;
 311
 312         BEFORE_ORIGINAL_FILE(fgets, LIBC);
 313
 314         cret = fgetsp(str, size, stream);
 315
 316         AFTER_PACK_ORIGINAL_FILEP(cret, (ret == NULL ? 0 : strlen(cret)),
 317                         stream, FD_API_READ, "sdp", str, size, stream);
 318
 319         return cret;
 320 }
 321 #endif
 322
 323 int fputc(int character, FILE* stream)
 324 {
 325         static int (*fputcp)(int character, FILE* stream);
 326
 327         BEFORE_ORIGINAL_FILE(fputc, LIBC);
 328         ret = fputcp(character, stream);
 329         AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE,
 330                         "dp", character, stream);
 331         return ret;
 332 }
 333
 334 int fputs(const char* str, FILE* stream)
 335 {
 336         static int (*fputsp)(const char* str, FILE* stream);
 337
 338         BEFORE_ORIGINAL_FILE(fputs, LIBC);
 339         ret = fputsp(str, stream);
 340         AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_WRITE, "sp", str, stream);
 341         return ret;
 342 }
 343
 344 int getc(FILE* stream)
 345 {
 346         static int (*getcp)(FILE* stream);
 347
 348         BEFORE_ORIGINAL_FILE(getc, LIBC);
 349         ret = getcp(stream);
 350         AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_READ, "p", stream);
 351         return ret;
 352 }
 353
 354 int putc(int character, FILE* stream)
 355 {
 356         static int (*putcp)(int character, FILE* stream);
 357
 358         BEFORE_ORIGINAL_FILE(putc, LIBC);
 359         ret = putcp(character, stream);
 360         AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE,
 361                         "dp", character, stream);
 362         return ret;
 363 }
 364
 365 int ungetc(int character, FILE* stream)
 366 {
 367         static int (*ungetcp)(int character, FILE* stream);
 368
 369         BEFORE_ORIGINAL_FILE(ungetc, LIBC);
 370         ret = ungetcp(character, stream);
 371         AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "dp", character, stream);
 372         return ret;
 373 }
 374
 375 size_t fread(void* ptr, size_t size, size_t count, FILE* stream)
 376 {
 377         static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
 378         size_t tret;
 379
 380         BEFORE_ORIGINAL_FILE(fread, LIBC);
 381
 382         tret = freadp(ptr, size, count, stream);
 383
 384         AFTER_PACK_ORIGINAL_FILEP(tret, 0, stream, FD_API_READ,
 385                         "pxxp", ptr, size, count, stream);
 386
 387         return tret;
 388 }
 389
 390 size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)
 391 {
 392         static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
 393         size_t tret;
 394
 395         BEFORE_ORIGINAL_FILE(fwrite, LIBC);
 396
 397         tret = fwritep(ptr, size, count, stream);
 398
 399         AFTER_PACK_ORIGINAL_FILEP(tret, 0, stream, FD_API_WRITE,
 400                         "pxxp", ptr, size, count, stream);
 401
 402         return tret;
 403 }
 404
 405 // *********************************************************
 406 // variable parameter function
 407 // *********************************************************
 408 int fprintf(FILE* stream, const char* format, ...)
 409 {
 410         static int (*vfprintfp)(FILE* stream, const char* format, ...);
 411
 412         BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
 413
 414         va_list arg;
 415         va_start(arg, format);
 416         ret = vfprintfp(stream, format, arg);
 417
 418         AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_WRITE, "ps", stream, format);
 419         va_end(arg);
 420
 421         return ret;
 422 }
 423
 424 int fscanf(FILE* stream, const char* format, ...)
 425 {
 426         static int (*vfscanfp)(FILE* stream, const char* format, ...);
 427
 428         BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
 429
 430         va_list arg;
 431         va_start(arg, format);
 432         ret = vfscanfp(stream, format, arg);
 433
 434         AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_READ, "ps", stream, format);
 435         va_end(arg);
 436
 437         return ret;
 438 }
 439
 440 #if !defined(DA_DEBUG_LOG) && !defined(PRINT_STDOUT)
 441 int printf(const char* format, ...)
 442 {
 443         static int (*vprintfp)(const char* format, ...);
 444
 445         BEFORE_ORIGINAL_FILE(vprintf, LIBC);
 446
 447         va_list arg;
 448         va_start(arg, format);
 449         ret = vprintfp(format, arg);
 450
 451         AFTER_PACK_ORIGINAL_NOFD(ret, ret, FD_API_WRITE, "s", format);
 452         va_end(arg);
 453
 454         return ret;
 455 }
 456 #endif
 457
 458 int scanf(const char* format, ...)
 459 {
 460         static int (*vscanfp)(const char* format, ...);
 461
 462         BEFORE_ORIGINAL_FILE(vscanf, LIBC);
 463
 464         va_list arg;
 465         va_start(arg, format);
 466         ret = vscanfp(format, arg);
 467
 468         AFTER_PACK_ORIGINAL_NOFD(ret, ret, FD_API_READ, "s", format);
 469         va_end(arg);
 470
 471         return ret;
 472 }
 473
 474 int getchar()
 475 {
 476         static int (*getcharp)();
 477
 478         BEFORE_ORIGINAL_FILE(getchar, LIBC);
 479         ret = getcharp();
 480         AFTER_PACK_ORIGINAL_NOFD(ret, (ret == EOF ? 0 : 1), FD_API_READ, "s", "");
 481         return ret;
 482 }
 483
 484 int putchar(int c)
 485 {
 486         static int (*putcharp)(int c);
 487
 488         BEFORE_ORIGINAL_FILE(putchar, LIBC);
 489         ret = putcharp(c);
 490         AFTER_PACK_ORIGINAL_NOFD(ret, (ret == EOF ? 0 : 1), FD_API_WRITE, "d", c);
 491         return ret;
 492 }
 493
 494 char* gets(char* str)
 495 {
 496         static char* (*getsp)(char* str);
 497         char* cret;
 498
 499         BEFORE_ORIGINAL_FILE(gets, LIBC);
 500
 501         cret = getsp(str);
 502
 503         AFTER_PACK_ORIGINAL_NOFD(cret, strlen(cret), FD_API_READ, "s", str);
 504
 505         return cret;
 506 }
 507
 508 #if !defined(DA_DEBUG_LOG) && !defined(PRINT_STDOUT)
 509 int puts(const char* str)
 510 {
 511         static int (*putsp)(const char* str);
 512
 513         BEFORE_ORIGINAL_FILE(puts, LIBC);
 514         ret = putsp(str);
 515         AFTER_PACK_ORIGINAL_NOFD(ret, ret, FD_API_WRITE, "s", str);
 516         return ret;
 517 }
 518 #endif
 519
 520 char* tmpnam(char* str)
 521 {
 522         static char* (*tmpnamp)(char* str);
 523         char* cret;
 524
 525         BEFORE_ORIGINAL_FILE(tmpnam, LIBC);
 526
 527         cret = tmpnamp(str);
 528
 529         AFTER_PACK_ORIGINAL_NOFD(cret, 0, FD_API_OTHER, "s", str);
 530
 531         return cret;
 532 }
 533
 534 void setbuf(FILE* stream, char* buf)
 535 {
 536         static void (*setbufp)(FILE* stream, char* buf);
 537
 538         BEFORE_ORIGINAL_FILE(setbuf, LIBC);
 539
 540         setbufp(stream, buf);
 541
 542         AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "pp", stream, buf);
 543 }
 544
 545 void setbuffer(FILE* stream, char* buf, size_t size)
 546 {
 547         static void (*setbufferp)(FILE* stream, char* buf, size_t size);
 548
 549         BEFORE_ORIGINAL_FILE(setbuffer, LIBC);
 550
 551         setbufferp(stream, buf, size);
 552
 553         AFTER_PACK_ORIGINAL_FILEP(0, size, stream, FD_API_OTHER,
 554                         "ppx", stream, buf, size);
 555 }
 556
 557 void setlinebuf(FILE* stream)
 558 {
 559         static int (*setlinebufp)(FILE* stream);
 560
 561         BEFORE_ORIGINAL_FILE(setlinebuf, LIBC);
 562
 563         setlinebufp(stream);
 564
 565         AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "p", stream);
 566 }
 567
 568 int setvbuf(FILE* stream, char* buf, int mode, size_t size)
 569 {
 570         static int (*setvbufp)(FILE* stream, char* buf, int mode, size_t size);
 571
 572         BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
 573         ret = setvbufp(stream,buf,mode,size);
 574         AFTER_PACK_ORIGINAL_FILEP(ret, size, stream, FD_API_OTHER,
 575                         "ppdx", stream, buf, mode, size);
 576         return ret;
 577 }
 578