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 #include "real_functions.h"
  47
  48 static enum DaOptions _sopt = OPT_FILE;
  49
  50 static inline char *get_abs_path(FILE *file, const char *fname,
  51                                  char *buf, size_t bufsiz)
  52 {
  53         char *path = file ? real_abs_path(fileno(file), buf, bufsiz): NULL;
  54
  55         if (!path)
  56                 path = absolutize_filepath(fname, buf, bufsiz);
  57
  58         return path;
  59 }
  60
  61 FILE* fopen(const char* filename, const char* mode)
  62 {
  63         static FILE* (*fopenp)(const char* filename, const char* mode);
  64         char buffer[PATH_MAX];
  65         FILE* fret;
  66
  67         BEFORE_ORIGINAL_FILE(fopen, LIBC);
  68
  69         fret = fopenp(filename, mode);
  70
  71         _filepath = get_abs_path(fret, filename, buffer, PATH_MAX);
  72
  73         AFTER_PACK_ORIGINAL_FILEP(API_ID_fopen,
  74                                   'p', fret, 0, fret, FD_API_OPEN, "s4s",
  75                                   filename, mode);
  76
  77         return fret;
  78 }
  79
  80 FILE* freopen(const char * filename, const char * mode, FILE * stream)
  81 {
  82         static FILE* (*freopenp)(const char *filename, const char *mode,
  83                                  FILE *stream);
  84         char buffer[PATH_MAX];
  85         FILE* fret;
  86
  87         BEFORE_ORIGINAL_FILE(freopen, LIBC);
  88
  89         fret = freopenp(filename, mode, stream);
  90
  91         _filepath = get_abs_path(fret, filename, buffer, PATH_MAX);
  92
  93         AFTER_PACK_ORIGINAL_FILEP(API_ID_freopen, 'p', fret, 0, fret, FD_API_OPEN,
  94                                   "s4sp", filename, mode,
  95                                   voidp_to_uint64(stream));
  96
  97         return fret;
  98 }
  99
 100 FILE* fdopen(int fildes, const char *mode)
 101 {
 102         static FILE* (*fdopenp)(int fildes, const char *mode);
 103         FILE* fret;
 104
 105         BEFORE_ORIGINAL_FILE(fdopen, LIBC);
 106
 107         fret = fdopenp(fildes, mode);
 108
 109         AFTER_PACK_ORIGINAL_FILEP(API_ID_fdopen,
 110                                   'p', fret, 0, fret, FD_API_OPEN, "ds", fildes, mode);
 111
 112         return fret;
 113 }
 114
 115 int fflush(FILE* stream)
 116 {
 117         static int (*fflushp)(FILE* stream);
 118
 119         BEFORE_ORIGINAL_FILE(fflush, LIBC);
 120         ret = fflushp(stream);
 121         AFTER_PACK_ORIGINAL_FILEP(API_ID_fflush,
 122                                   'd', ret, 0, stream, FD_API_OTHER, "p",
 123                                   voidp_to_uint64(stream));
 124         return ret;
 125 }
 126
 127 int fclose(FILE* stream)
 128 {
 129         static int (*fclosep)(FILE* stream);
 130         DECLARE_VARIABLE_FD;
 131
 132         GET_REAL_FUNC(fclose, LIBC);
 133
 134         PRE_PROBEBLOCK_BEGIN();
 135         GET_FD_FROM_FILEP(stream);
 136         if(_fd != -1) {
 137                 _fstatret = fstat(_fd, &_statbuf);
 138         }
 139         PRE_PROBEBLOCK_END();
 140
 141         ret = fclosep(stream);
 142
 143         POST_PACK_PROBEBLOCK_BEGIN();
 144         PREPARE_LOCAL_BUF();
 145         PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
 146                           API_ID_fclose,
 147                           "p", voidp_to_uint64(stream));
 148         PACK_COMMON_END('d', ret, newerrno, blockresult);
 149         POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
 150         POST_PACK_PROBEBLOCK_END();
 151
 152         return ret;
 153 }
 154
 155 FILE * tmpfile ( void )
 156 {
 157         static FILE* (*tmpfilep) ( void );
 158         FILE* fret;
 159
 160         BEFORE_ORIGINAL_FILE(tmpfile, LIBC);
 161         _filepath = "<temp file>";
 162         fret = tmpfilep();
 163         AFTER_PACK_ORIGINAL_FILEP(API_ID_tmpfile,
 164                                   'p', fret, 0, fret, FD_API_OPEN, "s", "");
 165         return fret;
 166 }
 167
 168 int fgetpos(FILE* stream, fpos_t* position)
 169 {
 170         static int (*fgetposp)(FILE* stream, fpos_t* position);
 171
 172         BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
 173         ret = fgetposp(stream, position);
 174         AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetpos,
 175                                   'd', ret, 0, stream, FD_API_OTHER, "pp",
 176                                   voidp_to_uint64(stream),
 177                                   voidp_to_uint64(position));
 178         return ret;
 179 }
 180
 181 int fseek(FILE* stream, long int offset, int origin)
 182 {
 183         static int (*fseekp)(FILE* stream, long int offset, int origin);
 184
 185         BEFORE_ORIGINAL_FILE(fseek, LIBC);
 186         ret = fseekp(stream, offset, origin);
 187         AFTER_PACK_ORIGINAL_FILEP(API_ID_fseek,
 188                                   'd', ret, (unsigned int)offset, stream, FD_API_OTHER,
 189                                   "pxd", voidp_to_uint64(stream),
 190                                   (uint64_t)(offset), origin);
 191         return ret;
 192 }
 193
 194 int fsetpos(FILE* stream, const fpos_t* pos)
 195 {
 196         static int (*fsetposp)(FILE* stream, const fpos_t* pos);
 197
 198         BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
 199         ret = fsetposp(stream, pos);
 200         AFTER_PACK_ORIGINAL_FILEP(API_ID_fsetpos,
 201                                   'd', ret, 0, stream, FD_API_OTHER, "pp",
 202                                   voidp_to_uint64(stream), voidp_to_uint64(pos));
 203         return ret;
 204 }
 205
 206 long int ftell(FILE* stream)
 207 {
 208         static long int (*ftellp)(FILE* stream);
 209         long int lret;
 210
 211         BEFORE_ORIGINAL_FILE(ftell, LIBC);
 212
 213         lret = ftellp(stream);
 214
 215         AFTER_PACK_ORIGINAL_FILEP(API_ID_ftell,
 216                                   'x', lret, 0, stream, FD_API_OTHER, "p",
 217                                   voidp_to_uint64(stream));
 218
 219         return lret;
 220 }
 221
 222 void rewind(FILE* stream)
 223 {
 224         static void (*rewindp)(FILE* stream);
 225
 226         BEFORE_ORIGINAL_FILE(rewind, LIBC);
 227
 228         rewindp(stream);
 229
 230         AFTER_PACK_ORIGINAL_FILEP(API_ID_rewind,
 231                                   'v', 0, 0, stream, FD_API_OTHER, "p",
 232                                   voidp_to_uint64(stream));
 233 }
 234
 235 void clearerr(FILE* stream)
 236 {
 237         static void (*clearerrp)(FILE* stream);
 238
 239         BEFORE_ORIGINAL_FILE(clearerr, LIBC);
 240
 241         clearerrp(stream);
 242
 243         AFTER_PACK_ORIGINAL_FILEP(API_ID_clearerr,
 244                                   'v', 0, 0, stream, FD_API_OTHER, "p",
 245                                   voidp_to_uint64(stream));
 246 }
 247
 248 int feof(FILE* stream)
 249 {
 250         static int (*feofp)(FILE* stream);
 251
 252         BEFORE_ORIGINAL_FILE(feof, LIBC);
 253         ret = feofp(stream);
 254         AFTER_PACK_ORIGINAL_FILEP(API_ID_feof,
 255                                   'd', ret, 0, stream, FD_API_OTHER, "p",
 256                                   voidp_to_uint64(stream));
 257         return ret;
 258 }
 259
 260 int ferror(FILE* stream)
 261 {
 262         static int (*ferrorp)(FILE* stream);
 263
 264         BEFORE_ORIGINAL_FILE(ferror, LIBC);
 265         ret = ferrorp(stream);
 266         AFTER_PACK_ORIGINAL_FILEP(API_ID_ferror,
 267                                   'd', ret, 0, stream, FD_API_OTHER, "p",
 268                                   voidp_to_uint64(stream));
 269         return ret;
 270 }
 271
 272 int fileno(FILE* stream)
 273 {
 274         static int (*filenop)(FILE* stream);
 275
 276         BEFORE_ORIGINAL_FILE(fileno, LIBC);
 277         ret = filenop(stream);
 278         AFTER_PACK_ORIGINAL_FILEP(API_ID_fileno,
 279                                   'd', ret, 0, stream, FD_API_OTHER, "p",
 280                                   voidp_to_uint64(stream));
 281         return ret;
 282 }
 283
 284
 285
 286 // *******************************************************************
 287 // File read / write APIs
 288 // *******************************************************************
 289
 290 int vfprintf(FILE* stream, const char* format, va_list arg)
 291 {
 292         static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
 293
 294         BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfprintf, 'd', vfprintf, LIBC, stream,
 295                                         FD_API_WRITE_START, "ps",
 296                                         voidp_to_uint64(stream), format);
 297
 298         ret = vfprintfp(stream, format, arg);
 299
 300         AFTER_ORIGINAL_START_END_FILEP(API_ID_vfprintf, 'd', ret, ret, stream,
 301                                        FD_API_WRITE_END, "ps",
 302                                        voidp_to_uint64(stream), format);
 303
 304         return ret;
 305 }
 306
 307 int vfscanf(FILE* stream, const char* format, va_list arg)
 308 {
 309         static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
 310
 311         BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfscanf, 'd', vfscanf, LIBC, stream,
 312                                         FD_API_READ_START, "ps",
 313                                         voidp_to_uint64(stream), format);
 314
 315         ret = vfscanfp(stream, format, arg);
 316
 317         AFTER_ORIGINAL_START_END_FILEP(API_ID_vfscanf, 'd', ret, ret, stream,
 318                                        FD_API_READ_END, "ps",
 319                                        voidp_to_uint64(stream), format);
 320
 321         return ret;
 322 }
 323
 324 int fgetc(FILE* stream)
 325 {
 326         static int (*fgetcp)(FILE* stream);
 327
 328         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgetc, 'd', fgetc, LIBC, stream,
 329                                         FD_API_READ_START, "p",
 330                                         voidp_to_uint64(stream));
 331
 332         ret = fgetcp(stream);
 333
 334         AFTER_ORIGINAL_START_END_FILEP(API_ID_fgetc, 'd', ret, (ret != EOF), stream,
 335                                        FD_API_READ_END, "p",
 336                                        voidp_to_uint64(stream));
 337
 338         return ret;
 339 }
 340
 341 #if 0   // why is this commented?
 342 char* fgets(char* str, int size, FILE* stream)
 343 {
 344         static char* (*fgetsp)(char* str, int num, FILE* stream);
 345         char* cret;
 346
 347         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgets, 'p', FD_API_READ_START,
 348                                 fgets, LIBC, stream, "sdp", str, size, stream);
 349
 350         cret = fgetsp(str, size, stream);
 351
 352         AFTER_ORIGINAL_START_END_FILEP(API_ID_fgets, 'p', cret, (ret == NULL ? 0 : strlen(cret)),
 353                         stream, FD_API_READ_END, "sdp", str, size, stream);
 354
 355         return cret;
 356 }
 357 #endif
 358
 359 int fputc(int character, FILE* stream)
 360 {
 361         static int (*fputcp)(int character, FILE* stream);
 362
 363         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputc, 'd', fputc, LIBC, stream,
 364                                         FD_API_WRITE_START, "dp", character,
 365                                         voidp_to_uint64(stream));
 366
 367         ret = fputcp(character, stream);
 368
 369         AFTER_ORIGINAL_START_END_FILEP(API_ID_fputc, 'd', ret, (ret == EOF ? 0 : 1),
 370                                        stream, FD_API_WRITE_END, "dp",
 371                                        character, voidp_to_uint64(stream));
 372
 373         return ret;
 374 }
 375
 376 int fputs(const char* str, FILE* stream)
 377 {
 378         static int (*fputsp)(const char* str, FILE* stream);
 379
 380         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputs, 'd', fputs, LIBC, stream,
 381                                         FD_API_WRITE_START, "sp", str,
 382                                         voidp_to_uint64(stream));
 383
 384         ret = fputsp(str, stream);
 385
 386         AFTER_ORIGINAL_START_END_FILEP(API_ID_fputs, 'd', ret, ret, stream,
 387                                        FD_API_WRITE_END, "sp", str,
 388                                        voidp_to_uint64(stream));
 389
 390         return ret;
 391 }
 392
 393 int getc(FILE* stream)
 394 {
 395         static int (*getcp)(FILE* stream);
 396
 397         BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', getc, LIBC, stream,
 398                                         FD_API_READ_START, "p",
 399                                         voidp_to_uint64(stream));
 400
 401         ret = getcp(stream);
 402
 403         AFTER_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', ret, (ret == EOF ? 0 : 1), stream,
 404                                        FD_API_READ_END, "p",
 405                                        voidp_to_uint64(stream));
 406
 407         return ret;
 408 }
 409
 410 int putc(int character, FILE* stream)
 411 {
 412         static int (*putcp)(int character, FILE* stream);
 413
 414         BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', putc, LIBC, stream,
 415                                         FD_API_WRITE_START, "dp", character,
 416                                         voidp_to_uint64(stream));
 417
 418         ret = putcp(character, stream);
 419
 420         AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', ret, (ret == EOF ? 0 : 1),
 421                                        stream, FD_API_WRITE_END, "dp",
 422                                        character, voidp_to_uint64(stream));
 423
 424         return ret;
 425 }
 426
 427 int ungetc(int character, FILE* stream)
 428 {
 429         static int (*ungetcp)(int character, FILE* stream);
 430
 431         BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', ungetc, LIBC, stream,
 432                                         FD_API_WRITE_START, "dp", character,
 433                                         voidp_to_uint64(stream));
 434
 435         ret = ungetcp(character, stream);
 436
 437         AFTER_ORIGINAL_START_END_FILEP(API_ID_ungetc, 'd', ret, 0, stream,
 438                                        FD_API_OTHER, "dp", character,
 439                                        voidp_to_uint64(stream));
 440
 441         return ret;
 442 }
 443
 444 size_t fread(void* ptr, size_t size, size_t count, FILE* stream)
 445 {
 446         static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
 447         size_t tret;
 448
 449         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fread, 'x', fread, LIBC, stream,
 450                                         FD_API_READ_START, "pxxp",
 451                                         voidp_to_uint64(ptr),
 452                                         (uint64_t)(size),
 453                                         (uint64_t)(count),
 454                                         voidp_to_uint64(stream));
 455
 456         tret = freadp(ptr, size, count, stream);
 457
 458         AFTER_ORIGINAL_START_END_FILEP(API_ID_fread, 'x', tret, tret*size, stream,
 459                                        FD_API_READ_END, "pxxp",
 460                                        voidp_to_uint64(ptr),
 461                                        (uint64_t)(size),
 462                                        (uint64_t)(count),
 463                                        voidp_to_uint64(stream));
 464
 465         return tret;
 466 }
 467
 468 size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)
 469 {
 470         static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
 471         size_t tret;
 472
 473         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fwrite, 'x', fwrite, LIBC, stream,
 474                                         FD_API_WRITE_START, "pxxp",
 475                                         voidp_to_uint64(ptr),
 476                                         (uint64_t)(size),
 477                                         (uint64_t)(count),
 478                                         voidp_to_uint64(stream));
 479
 480         tret = fwritep(ptr, size, count, stream);
 481
 482         AFTER_ORIGINAL_START_END_FILEP(API_ID_fwrite, 'x', tret, tret*size, stream,
 483                                        FD_API_WRITE_END, "pxxp",
 484                                        voidp_to_uint64(ptr),
 485                                        (uint64_t)(size),
 486                                        (uint64_t)(count),
 487                                        voidp_to_uint64(stream));
 488
 489         return tret;
 490 }
 491
 492 // *********************************************************
 493 // variable parameter function
 494 // *********************************************************
 495 int fprintf(FILE* stream, const char* format, ...)
 496 {
 497         static int (*vfprintfp)(FILE* stream, const char* format, ...);
 498
 499         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fprintf, 'd', vfprintf, LIBC, stream,
 500                                         FD_API_WRITE_START, "ps",
 501                                         voidp_to_uint64(stream), format);
 502
 503         va_list arg;
 504         va_start(arg, format);
 505
 506         ret = vfprintfp(stream, format, arg);
 507
 508         AFTER_ORIGINAL_START_END_FILEP(API_ID_fprintf, 'd', ret, ret, stream,
 509                                        FD_API_WRITE_END, "ps",
 510                                        voidp_to_uint64(stream), format);
 511
 512         va_end(arg);
 513
 514         return ret;
 515 }
 516
 517 int fscanf(FILE* stream, const char* format, ...)
 518 {
 519         static int (*vfscanfp)(FILE* stream, const char* format, ...);
 520
 521         BEFORE_ORIGINAL_START_END_FILEP(API_ID_fscanf, 'd', vfscanf, LIBC, stream,
 522                                         FD_API_READ_START, "ps",
 523                                         voidp_to_uint64(stream), format);
 524
 525         va_list arg;
 526         va_start(arg, format);
 527
 528         ret = vfscanfp(stream, format, arg);
 529
 530         AFTER_ORIGINAL_START_END_FILEP(API_ID_fscanf, 'd', ret, ret, stream,
 531                                        FD_API_READ_END, "ps",
 532                                        voidp_to_uint64(stream), format);
 533
 534         va_end(arg);
 535
 536         return ret;
 537 }
 538
 539 #if !defined(DA_DEBUG_LOG) && !defined(PRINT_STDOUT)
 540 int printf(const char* format, ...)
 541 {
 542         static int (*vprintfp)(const char* format, ...);
 543
 544         BEFORE_ORIGINAL_START_END_NOFD(API_ID_printf, 'd', vprintf, LIBC,
 545                                 FD_API_WRITE_START, "s", format);
 546
 547         va_list arg;
 548         va_start(arg, format);
 549         ret = vprintfp(format, arg);
 550
 551         AFTER_ORIGINAL_START_END_NOFD(API_ID_printf, 'd', ret, ret,
 552                                 FD_API_WRITE_END, "s", format);
 553
 554         va_end(arg);
 555
 556         return ret;
 557 }
 558 #endif
 559
 560 int scanf(const char* format, ...)
 561 {
 562         static int (*vscanfp)(const char* format, ...);
 563
 564         BEFORE_ORIGINAL_START_END_NOFD(API_ID_scanf, 'd', vscanf, LIBC,
 565                                 FD_API_READ_START, "s", format);
 566
 567         va_list arg;
 568         va_start(arg, format);
 569         ret = vscanfp(format, arg);
 570
 571         AFTER_ORIGINAL_START_END_NOFD(API_ID_scanf, 'd', ret, ret,
 572                                  FD_API_READ_END, "s", format);
 573
 574         va_end(arg);
 575
 576         return ret;
 577 }
 578
 579 int getchar()
 580 {
 581         static int (*getcharp)();
 582
 583         BEFORE_ORIGINAL_START_END_NOFD(API_ID_getchar, 'd', getchar, LIBC,
 584                                 FD_API_READ_START, "", 0);
 585
 586         ret = getcharp();
 587
 588         AFTER_ORIGINAL_START_END_NOFD(API_ID_getchar, 'd', ret, (ret == EOF ? 0 : 1),
 589                                 FD_API_READ_END, "", 0);
 590
 591         return ret;
 592 }
 593
 594 int putchar(int c)
 595 {
 596         static int (*putcharp)(int c);
 597
 598         BEFORE_ORIGINAL_START_END_NOFD(API_ID_putchar, 'd', putchar, LIBC,
 599                                 FD_API_WRITE_START, "d", c);
 600
 601         ret = putcharp(c);
 602
 603         AFTER_ORIGINAL_START_END_NOFD(API_ID_putchar, 'd', ret, (ret == EOF ? 0 : 1),
 604                                 FD_API_WRITE_END, "d", c);
 605
 606         return ret;
 607 }
 608
 609 char* gets(char* str)
 610 {
 611         static char* (*getsp)(char* str);
 612         char* cret;
 613
 614         BEFORE_ORIGINAL_START_END_NOFD(API_ID_gets, 'p', gets, LIBC,
 615                                 FD_API_READ_START, "s", str);
 616
 617         cret = getsp(str);
 618
 619         AFTER_ORIGINAL_START_END_NOFD(API_ID_gets, 'p', cret, strlen(cret),
 620                                 FD_API_READ_END, "s", str);
 621
 622         return cret;
 623 }
 624
 625 #if !defined(DA_DEBUG_LOG) && !defined(PRINT_STDOUT)
 626 int puts(const char* str)
 627 {
 628         static int (*putsp)(const char* str);
 629
 630         BEFORE_ORIGINAL_START_END_NOFD(API_ID_puts, 'd', puts, LIBC,
 631                                 FD_API_WRITE_START, "s", str);
 632
 633         ret = putsp(str);
 634
 635         AFTER_ORIGINAL_START_END_NOFD(API_ID_puts, 'd', ret, ret,
 636                                 FD_API_WRITE_END, "s", str);
 637
 638         return ret;
 639 }
 640 #endif
 641
 642
 643
 644 void setbuf(FILE* stream, char* buf)
 645 {
 646         static void (*setbufp)(FILE* stream, char* buf);
 647
 648         BEFORE_ORIGINAL_FILE(setbuf, LIBC);
 649
 650         setbufp(stream, buf);
 651
 652         AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuf,
 653                                   'v', 0, 0, stream, FD_API_OTHER, "pp",
 654                                   voidp_to_uint64(stream),
 655                                   voidp_to_uint64(buf));
 656 }
 657
 658 void setbuffer(FILE* stream, char* buf, size_t size)
 659 {
 660         static void (*setbufferp)(FILE* stream, char* buf, size_t size);
 661
 662         BEFORE_ORIGINAL_FILE(setbuffer, LIBC);
 663
 664         setbufferp(stream, buf, size);
 665
 666         AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuffer,
 667                                   'v', 0, size, stream, FD_API_OTHER,
 668                                   "ppx", voidp_to_uint64(stream),
 669                                   voidp_to_uint64(buf), (uint64_t)(size));
 670 }
 671
 672 void setlinebuf(FILE* stream)
 673 {
 674         static int (*setlinebufp)(FILE* stream);
 675
 676         BEFORE_ORIGINAL_FILE(setlinebuf, LIBC);
 677
 678         setlinebufp(stream);
 679
 680         AFTER_PACK_ORIGINAL_FILEP(API_ID_setlinebuf,
 681                                   'v', 0, 0, stream, FD_API_OTHER, "p",
 682                                   voidp_to_uint64(stream));
 683 }
 684
 685 int setvbuf(FILE* stream, char* buf, int mode, size_t size)
 686 {
 687         static int (*setvbufp)(FILE* stream, char* buf, int mode, size_t size);
 688
 689         BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
 690         ret = setvbufp(stream,buf,mode,size);
 691         AFTER_PACK_ORIGINAL_FILEP(API_ID_setvbuf,
 692                                   'd', ret, size, stream, FD_API_OTHER,
 693                                   "ppdx",
 694                                   voidp_to_uint64(stream),
 695                                   voidp_to_uint64(buf), mode,
 696                                   (uint64_t)(size));
 697         return ret;
 698 }