1. Список говнокодов пользователя rOBHOBO3Hblu_nemyx

    Всего: 2

  2. Си / Говнокод #29064

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 97
    98. 98
    99. 99
    /* Windows doesn't support the fork() call; so we fake it by invoking
       another copy of Wget with the same arguments with which we were
       invoked.  The child copy of Wget should perform the same initialization
       sequence as the parent; so we should have two processes that are
       essentially identical.  We create a specially named section object that
       allows the child to distinguish itself from the parent and is used to
       exchange information between the two processes.  We use an event object
       for synchronization.  */
    static void
    fake_fork (void)
    {
      char exe[MAX_PATH + 1];
      DWORD exe_len, le;
      SECURITY_ATTRIBUTES sa;
      HANDLE section, event, h[2];
      STARTUPINFO si;
      PROCESS_INFORMATION pi;
      struct fake_fork_info *info;
      char *name;
      BOOL rv;
    
      section = pi.hProcess = pi.hThread = NULL;
    
      /* Get the fully qualified name of our executable.  This is more reliable
         than using argv[0].  */
      exe_len = GetModuleFileName (GetModuleHandle (NULL), exe, sizeof (exe));
      if (!exe_len || (exe_len >= sizeof (exe)))
        return;
    
      sa.nLength = sizeof (sa);
      sa.lpSecurityDescriptor = NULL;
      sa.bInheritHandle = TRUE;
    
      /* Create an anonymous inheritable event object that starts out
         non-signaled.  */
      event = CreateEvent (&sa, FALSE, FALSE, NULL);
      if (!event)
        return;
    
      /* Create the child process detached form the current console and in a
         suspended state.  */
      xzero (si);
      si.cb = sizeof (si);
      rv = CreateProcess (exe, GetCommandLine (), NULL, NULL, TRUE,
                          CREATE_SUSPENDED | DETACHED_PROCESS,
                          NULL, NULL, &si, &pi);
      if (!rv)
        goto cleanup;
    
      /* Create a named section object with a name based on the process id of
         the child.  */
      name = make_section_name (pi.dwProcessId);
      section =
          CreateFileMapping (INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
                             sizeof (struct fake_fork_info), name);
      le = GetLastError();
      xfree (name);
      /* Fail if the section object already exists (should not happen).  */
      if (!section || (le == ERROR_ALREADY_EXISTS))
        {
          rv = FALSE;
          goto cleanup;
        }
    
      /* Copy the event handle into the section object.  */
      info = MapViewOfFile (section, FILE_MAP_WRITE, 0, 0, 0);
      if (!info)
        {
          rv = FALSE;
          goto cleanup;
        }
    
      info->event = event;
    
      UnmapViewOfFile (info);
    
      /* Start the child process.  */
      rv = ResumeThread (pi.hThread);
      if (!rv)
        {
          TerminateProcess (pi.hProcess, (DWORD) -1);
          goto cleanup;
        }
    
      /* Wait for the child to signal to us that it has done its part.  If it
         terminates before signaling us it's an error.  */
    
      h[0] = event;
      h[1] = pi.hProcess;
      rv = WAIT_OBJECT_0 == WaitForMultipleObjects (2, h, FALSE, 5 * 60 * 1000);
      if (!rv)
        goto cleanup;
    
      info = MapViewOfFile (section, FILE_MAP_READ, 0, 0, 0);
      if (!info)
        {
          rv = FALSE;
          goto cleanup;
        }

    Из исходников wget.

    https://git.savannah.gnu.org/cgit/wget.git/tree/src/mswindows.c

    rOBHOBO3Hblu_nemyx, 06 Декабря 2024

    Комментарии (11)
  3. Куча / Говнокод #29062

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    Говновозный оффтоп #1
    
           _.--,_......----..__
           \  .'          '    ```--...__      \
            \;           '            .  '.   ||
            :           '            '     \ .''.
          .';          :            '       .|  |.--..___
         /   \         |           :        :|  /.------.\
        /    .'._      :           |        ||  ||      |\\
       /.-. /|-| `-.               :        ;|  ||______|_\`.______
      //  // |-|    \   '           '      / |  ||='      | |      `.
     //  //\\|-|     `-._'           '   .'  |  ||        | |        \
    /.-.//  \\-|_________```------------` ___'. ||        | '_.--.   <)
    '._.'  /  .-----.   .-----.   .''''''''.    |'--..____| /  _  \   |
           |_/.'   '.\_/.'   '.\_[ [ [  ] ] ]___|_________.'.'   '.\  ]
             :  .-.  : :  .-.  :  '........'    (_________):  .-.  :`-'
             :  '-'  : :  '-'  :                           :  '-'  :
              '._ _.'   '._ _.'                             '._ _.'

    Предыдущих оффтопов нету.

    rOBHOBO3Hblu_nemyx, 27 Ноября 2024

    Комментарии (113)