API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 24th, 2019
81
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.10 KB | None | 0 0
raw download clone embed print report
  1. //
  2. // main.c
  3. // testforloop
  4. //
  5. // Created by Yaniv Mashat on 3/6/19.
  6. // Copyright © 2019 CydiaDevsIL. All rights reserved.
  7. //
  8.  
  9. #include <stdio.h>
  10. #include <mach/thread_act.h>
  11. #include <mach/task.h>
  12. #include <mach/mach.h>
  13. #include <errno.h> // errno
  14. #include <sched.h> // sched_yield
  15. #include <stdlib.h> // malloc, free
  16. #include <string.h> // strerror
  17. #include <unistd.h>
  18. //#include "helper.h"
  19. int main(int argc, const char * argv[]) {
  20. kern_return_t kr = KERN_FAILURE;
  21. pid_t pid;
  22. task_t child_task;
  23. task_t a;
  24. ledger_t ledger;
  25. ledger_array_t ledger_array;
  26. mach_msg_type_number_t ledger_count;
  27. boolean_t inhearit = TRUE;
  28. task_info_data_t info;
  29. mach_msg_type_number_t count;
  30. struct task_basic_info * task_basic_info;
  31.  
  32. if (argc == 2) {
  33. inhearit = (atoi(argv[1])) ? TRUE : FALSE;
  34.  
  35. }
  36. ledger_count =1;
  37. ledger = (ledger_t)0;
  38. ledger_array = &ledger;
  39.  
  40. // thread_act_array_t act_list[10];
  41. int i =0;
  42. printf("our pid: %d \n", getpid());
  43.  
  44. //MARK: -
  45. //MARK: a: Get first task port
  46.  
  47. while (kr != KERN_SUCCESS) {
  48.  
  49. if (i != getpid()) {
  50. kr= task_for_pid(mach_task_self(), i, &a);
  51. printf("pid: %d \n", i);
  52. }
  53. i++;
  54. }
  55.  
  56. //MARK: -
  57. //MARK: a: Check task port
  58.  
  59. if (MACH_PORT_VALID(a)) {
  60. printf("got a valid task: 0x%x\n", a);
  61. }
  62.  
  63. //MARK: -
  64. //MARK: Allocate 10 mach_port array
  65.  
  66. mach_port_t e [10];
  67.  
  68. for (int i =0; i<10; i++) {
  69. kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &e[i]);
  70. mach_error("mach_port_allocate:", kr);
  71. }
  72.  
  73. int thread_count =0;
  74. mach_msg_type_number_t max = 30;
  75. thread_act_port_array_t our_task_threads;
  76. thread_act_t b;
  77. thread_act_t c;
  78.  
  79. //MARK: -
  80. //MARK: Get a's Task threads into our_task_threads
  81.  
  82. kr= task_threads(a, &our_task_threads, &max);
  83. mach_error("task_threads:", kr);
  84.  
  85. //MARK: -
  86. //MARK: cout a's Task threads from our_task_threads
  87.  
  88. for (int i =0; i<1000; i++) {
  89. if (MACH_PORT_VALID(our_task_threads[i])) {
  90. printf("got valid thread in task: 0x%x\n", our_task_threads[i]);
  91. thread_count++;
  92. }
  93. }
  94. printf("we got %d threads in our task\n", thread_count);
  95. thread_count =0;
  96.  
  97. //MARK: -
  98. //MARK: Add 2 new threads in a's Task space
  99.  
  100. kr = thread_create(a, &b); mach_error("thread_create:", kr);
  101. if (MACH_PORT_VALID(b)) {
  102. printf("got valid thread: 0x%x\n", b);
  103. }
  104. kr = thread_create(a, &c); mach_error("thread_create:", kr);
  105. if (MACH_PORT_VALID(b)) {
  106. printf("got valid thread: 0x%x\n", c);
  107. }
  108.  
  109. //MARK: -
  110. //MARK: Get a's Task threads into our_task_threads
  111.  
  112. kr= task_threads(a, &our_task_threads, &max);
  113. mach_error("task_threads:", kr);
  114.  
  115. //MARK: -
  116. //MARK: cout a's Task threads from our_task_threads
  117. //MARK: -
  118.  
  119. for (int i =0; i<1000; i++) {
  120. if (MACH_PORT_VALID(our_task_threads[i])) {
  121. printf("got valid thread in task: 0x%x\n", our_task_threads[i]);
  122. thread_count++;
  123. }
  124. }
  125. printf("we got %d threads in our task\n", thread_count);
  126. #define ARM_THREAD_STATE64 6
  127. mach_port_t maybe;
  128. // kr= thread_get_mach_voucher(mach_thread_self(), 0, &maybe);
  129.  
  130. kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &maybe);
  131. mach_error("mach_port_allocate:", kr);
  132. kr = mach_port_insert_right(mach_task_self(), maybe, maybe, MACH_MSG_TYPE_MAKE_SEND);
  133. mach_error("mach_port_insert_right:", kr);
  134. printf("port to test: 0x%x\n", maybe);
  135.  
  136. for (int i =0; i<14; i++) {
  137. if (EXC_MASK_ALL & (1 << i)) {
  138. printf("entering port to %d index\n", i);
  139. }
  140.  
  141. }
  142. int plz = 0;
  143. //FIXME: -
  144. //FIXME: this loop is not running
  145. while (plz & (1 << 1)) {
  146. printf("plz: %d\n", plz);
  147. plz++;
  148.  
  149. }
  150.  
  151.  
  152. kr= thread_set_exception_ports(c, EXC_MASK_ALL, maybe, EXCEPTION_STATE,ARM_THREAD_STATE64 );
  153. for (int i =0; i<1000; i++) {
  154. if (MACH_PORT_VALID(our_task_threads[thread_count -i])) {
  155. kr= thread_set_exception_ports(our_task_threads[thread_count - i], EXC_MASK_ALL, maybe, EXCEPTION_STATE,ARM_THREAD_STATE64 );
  156. kr= thread_set_exception_ports(our_task_threads[thread_count - i], EXC_MASK_SYSCALL, maybe, EXCEPTION_DEFAULT ,ARM_THREAD_STATE64 );
  157. kr= thread_set_exception_ports(our_task_threads[thread_count - i], EXC_MASK_CRASH , maybe, 3 ,ARM_THREAD_STATE64 );
  158. kr= thread_set_exception_ports(our_task_threads[thread_count - i], EXC_MASK_CRASH , maybe, 7 ,ARM_THREAD_STATE64 );
  159. mach_error("thread_set_exception_ports:", kr);
  160. // thread_count++;
  161. }
  162. }
  163.  
  164.  
  165. // for (int i =0; i<1000; i++) {
  166. // if (MACH_PORT_VALID(our_task_threads[thread_count - i])) {
  167. // kr = task_generate_corpse(a, e);
  168. // mach_error("task_generate_corespe:", kr);
  169. // thread_count++;
  170. // }
  171. // }
  172. // mach_error("thread_set_exception_ports:", kr);
  173.  
  174. // kr = task_generate_corpse(a, e);
  175. // mach_error("task_generate_corespe:", kr);
  176. // kr = task_generate_corpse(a, e);
  177. // mach_error("task_generate_corespe:", kr);
  178.  
  179. // exception_mask_t mask = EXC_MASK_ALL;
  180. //exception_mask_array_t masks = NULL;
  181. // exception_handler_array_t handlers = NULL;//
  182. //exception_behavior_array_t beavhior = NULL ;
  183. //exception_flavor_array_t flavors = NULL;
  184. // mach_msg_type_number_t *max2 = 30;
  185. struct exc_port_info {
  186. mach_msg_type_number_t count;
  187. mach_port_t ports[EXC_TYPES_COUNT];
  188. exception_mask_t masks[EXC_TYPES_COUNT];
  189. exception_behavior_t behaviors[EXC_TYPES_COUNT];
  190. thread_state_flavor_t flavors[EXC_TYPES_COUNT];
  191. };
  192. struct exc_port_info aa;
  193. for (int i =0; i<30; i++) {
  194. // char mask_string[200];
  195. // char behavior_string[30];
  196. //get_exc_mask_string(masks[i], mask_string, sizeof(mask_string));
  197. // get_exc_behavior_string(beavhior[i], behavior_string, sizeof(behavior_string));
  198. }
  199. kr= thread_set_exception_ports(c, EXC_MASK_SYSCALL, maybe, EXCEPTION_DEFAULT ,ARM_THREAD_STATE64 );
  200. kr= thread_set_exception_ports(c, EXC_MASK_CRASH , maybe, 3 ,ARM_THREAD_STATE64 );
  201. kr= thread_set_exception_ports(c, EXC_MASK_CRASH , maybe, 7 ,ARM_THREAD_STATE64 );
  202. kr= thread_set_exception_ports(c, plz, maybe, EXCEPTION_STATE,ARM_THREAD_STATE64 );
  203. kr = thread_get_exception_ports(c, EXC_MASK_ALL, aa.masks, &aa.count, aa.ports, aa.behaviors, aa.flavors);
  204.  
  205.  
  206. kr= thread_set_exception_ports(0xae03, EXC_MASK_SYSCALL, maybe, EXCEPTION_DEFAULT ,ARM_THREAD_STATE64 );
  207. kr= thread_set_exception_ports(0xae03, EXC_MASK_CRASH , maybe, 3 ,ARM_THREAD_STATE64 );
  208. mach_error("thread_set_exception_ports:", kr);
  209. kr= thread_set_exception_ports(0xae03, EXC_MASK_CRASH , maybe, 7 ,ARM_THREAD_STATE64 );
  210. kr= thread_set_exception_ports(0xae03, plz, maybe, EXCEPTION_STATE,ARM_THREAD_STATE64 );
  211. kr = thread_get_exception_ports(0xae03, EXC_MASK_ALL, aa.masks, &aa.count, aa.ports, aa.behaviors, aa.flavors);
  212. mach_error("thread_set_exception_ports:", kr);
  213.  
  214. int count_port =0;
  215. for (int i =0; i<14; i++) {
  216.  
  217. printf("0x%x\n", aa.ports[i]);
  218. if (maybe == aa.ports[i]) {
  219. printf("we got the port in the %d index\n", i);
  220. count_port++;
  221. }
  222.  
  223. }
  224. if (count_port > 1) {
  225. printf("same port in thread!\n");
  226. }
  227. // kr = thread_get_exception_ports(c, EXC_MASK_ALL, masks, &max2, handlers, beavhior, flavors);
  228. mach_error("thread_get_exception_ports", kr);
  229. for (int i =0; i<100; i++) {
  230. // if (MACH_PORT_VALID(beavhior[i]) && beavhior[i]==maybe) {
  231. // printf("got exception portat index %d\n", i);
  232. //}
  233. }
  234.  
  235.  
  236.  
  237. for (i = 0; i<10; i++) {
  238. printf("0x%x\n", e[i]);
  239. }
  240.  
  241. for (int i =0; i < 1000; i++) {
  242. if (MACH_PORT_VALID(our_task_threads[i])) {
  243.  
  244. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_SYSCALL, maybe, 1 ,ARM_THREAD_STATE64 );
  245. mach_error("thread_set_exception_ports:", kr);
  246. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_CRASH , maybe, 2 ,ARM_THREAD_STATE64 );
  247. mach_error("thread_set_exception_ports:", kr);
  248. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_GUARD , maybe, 3 ,ARM_THREAD_STATE64 );
  249. mach_error("thread_set_exception_ports:", kr);
  250. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_RESOURCE, maybe, 1,7 );
  251. mach_error("thread_set_exception_ports:", kr);
  252. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_MACHINE, maybe, 2,5 );
  253.  
  254. mach_error("thread_set_exception_ports:", kr);
  255. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_SOFTWARE, maybe, 1,9 );
  256. mach_error("thread_set_exception_ports:", kr);
  257. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_EMULATION, maybe, 2,3 );
  258. mach_error("thread_set_exception_ports:", kr);
  259.  
  260. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_RPC_ALERT, maybe, 3,1 );
  261. mach_error("thread_set_exception_ports:", kr);
  262. kr= thread_set_exception_ports(our_task_threads[i], EXC_MASK_BAD_INSTRUCTION, maybe, 1,0 );
  263. mach_error("thread_set_exception_ports:", kr);
  264. kr= thread_set_exception_ports(our_task_threads[i],EXC_MASK_ARITHMETIC, maybe, 3,0 );
  265. mach_error("thread_set_exception_ports:", kr);
  266. kr= thread_set_exception_ports(our_task_threads[i],EXC_MASK_MACH_SYSCALL, maybe, 3,9 );
  267. mach_error("thread_set_exception_ports:", kr);
  268. kr= thread_set_exception_ports(our_task_threads[i],EXC_MASK_BREAKPOINT, maybe, 3,8 );
  269. mach_error("thread_set_exception_ports:", kr);
  270. kr= thread_set_exception_ports(our_task_threads[i],EXC_MASK_BAD_ACCESS, maybe, 1,2 );
  271. mach_error("thread_set_exception_ports:", kr);
  272. }
  273. }
  274.  
  275. kr= thread_set_exception_ports(c, EXC_MASK_SYSCALL, maybe, 1 ,ARM_THREAD_STATE64 );
  276. mach_error("thread_set_exception_ports:", kr);
  277. kr= thread_set_exception_ports(c, EXC_MASK_CRASH , maybe, 2 ,ARM_THREAD_STATE64 );
  278. mach_error("thread_set_exception_ports:", kr);
  279. kr= thread_set_exception_ports(c, EXC_MASK_GUARD , maybe, 3 ,ARM_THREAD_STATE64 );
  280. mach_error("thread_set_exception_ports:", kr);
  281. kr= thread_set_exception_ports(c, EXC_MASK_RESOURCE, maybe, 1,7 );
  282. mach_error("thread_set_exception_ports:", kr);
  283. kr = task_generate_corpse(a, e);
  284. mach_error("task_generate_corespe:", kr);
  285. task_t corspe2 = e[0];
  286. printf("0x%x\n", corspe2);
  287. // for (i = 0; i<10; i++) {
  288. // printf("0x%x\n", e[i]);
  289. // }
  290.  
  291. mach_port_deallocate(mach_task_self(), maybe);
  292. kr = task_generate_corpse(a, e);
  293. mach_error("task_generate_corespe:", kr);
  294. task_t corspe1 = e[0];
  295. printf("0x%x\n", corspe1);
  296. // for (i = 0; i<10; i++) {
  297. // printf("0x%x\n", e[i]);
  298. //}
  299. thread_act_port_array_t our_task_corspe_threads;
  300. thread_act_port_array_t our_task_corspe_threads1;
  301. kr= task_threads(corspe1, &our_task_corspe_threads, &max);
  302. mach_error("task_threads:", kr);
  303. kr= task_threads(corspe2, &our_task_corspe_threads1, &max);
  304. mach_error("task_threads:", kr);
  305.  
  306.  
  307.  
  308. // for (i = 0; i<1000; i++) {
  309. // if (MACH_PORT_VALID(our_task_threads[i]) && MACH_PORT_VALID(our_task_corspe_threads1[i])) {
  310. // if (our_task_corspe_threads[i] == our_task_corspe_threads1[i]) {
  311. // printf("same thread!\n");
  312. // }else{
  313. // printf("diffrent\n");
  314. // struct exc_port_info bb;
  315. // struct exc_port_info cc;
  316. // kr = thread_get_exception_ports(our_task_corspe_threads[i], EXC_MASK_ALL, bb.masks, &bb.count, bb.ports, bb.behaviors, bb.flavors);
  317. // kr = thread_get_exception_ports(our_task_corspe_threads1[i], EXC_MASK_ALL, cc.masks, &cc.count, cc.ports, cc.behaviors, cc.flavors);
  318. // for (int i =0; i<14; i++) {
  319. //
  320. // printf("0x%x\n", bb.ports[i]);
  321. // if (cc.ports[i] == bb.ports[i]) {
  322. // printf("same port\n");
  323.  
  324. // }else{
  325.  
  326. // printf("not smae at all\n");
  327.  
  328. // }
  329.  
  330. // }
  331. // }
  332. // }
  333. // }
  334.  
  335.  
  336.  
  337.  
  338.  
  339.  
  340.  
  341. for (int i =0; i<1000; i++) {
  342. // if (MACH_PORT_VALID(our_task_corspe_threads[i])) {
  343. if (our_task_corspe_threads[i] != our_task_threads[i]) {
  344. printf("got diffrent thread in index %d\n", i);
  345. printf("thread in original task: 0x%x\n", our_task_threads[i]);
  346. printf("thread in corspe task: 0x%x\n", our_task_corspe_threads[i]);
  347. struct exc_port_info bb;
  348. kr = thread_get_exception_ports(our_task_corspe_threads[i], EXC_MASK_ALL, bb.masks, &bb.count, bb.ports, bb.behaviors, bb.flavors);
  349. count_port =0;
  350. for (int i =0; i<14; i++) {
  351.  
  352. printf("0x%x\n", bb.ports[i]);
  353. if (maybe == bb.ports[i]) {
  354. printf("we got the port in the %d index\n", i);
  355. count_port++;
  356. }
  357.  
  358. }
  359.  
  360. }
  361. }
  362.  
  363.  
  364.  
  365.  
  366.  
  367.  
  368. kr= thread_set_exception_ports(c, EXC_MASK_SYSCALL, maybe, 1 ,ARM_THREAD_STATE64 );
  369. mach_error("thread_set_exception_ports:", kr);
  370. kr= thread_set_exception_ports(c, EXC_MASK_CRASH , maybe, 2 ,ARM_THREAD_STATE64 );
  371. mach_error("thread_set_exception_ports:", kr);
  372. kr= thread_set_exception_ports(c, EXC_MASK_GUARD , maybe, 3 ,ARM_THREAD_STATE64 );
  373. mach_error("thread_set_exception_ports:", kr);
  374. kr= thread_set_exception_ports(c, EXC_MASK_RESOURCE, maybe, 1,7 );
  375. mach_error("thread_set_exception_ports:", kr);
  376. kr= thread_set_exception_ports(c, EXC_MASK_MACHINE, maybe, 2,5 );
  377.  
  378. mach_error("thread_set_exception_ports:", kr);
  379. kr= thread_set_exception_ports(c, EXC_MASK_SOFTWARE, maybe, 1,9 );
  380. mach_error("thread_set_exception_ports:", kr);
  381. kr= thread_set_exception_ports(c, EXC_MASK_EMULATION, maybe, 2,3 );
  382. mach_error("thread_set_exception_ports:", kr);
  383.  
  384. kr= thread_set_exception_ports(c, EXC_MASK_RPC_ALERT, maybe, 3,1 );
  385. mach_error("thread_set_exception_ports:", kr);
  386. kr= thread_set_exception_ports(c, EXC_MASK_BAD_INSTRUCTION, maybe, 1,0 );
  387. mach_error("thread_set_exception_ports:", kr);
  388. kr= thread_set_exception_ports(c,EXC_MASK_ARITHMETIC, maybe, 3,0 );
  389. mach_error("thread_set_exception_ports:", kr);
  390. kr= thread_set_exception_ports(c,EXC_MASK_MACH_SYSCALL, maybe, 3,9 );
  391. mach_error("thread_set_exception_ports:", kr);
  392. kr= thread_set_exception_ports(c,EXC_MASK_BREAKPOINT, maybe, 3,8 );
  393. mach_error("thread_set_exception_ports:", kr);
  394. kr= thread_set_exception_ports(c,EXC_MASK_BAD_ACCESS, maybe, 1,2 );
  395. mach_error("thread_set_exception_ports:", kr);
  396.  
  397. task_t corspe_task = e[0];
  398. mach_msg_type_number_t max1 = 30;
  399. thread_act_port_array_t our_task_threads_corspe;
  400. thread_act_t b1;
  401. thread_act_t c1;
  402. kr= task_threads(corspe_task, &our_task_threads_corspe, &max1);
  403. mach_error("task_threads:", kr);
  404.  
  405.  
  406.  
  407. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_SYSCALL, maybe, 1 ,ARM_THREAD_STATE64 );
  408. mach_error("thread_set_exception_ports:", kr);
  409. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_CRASH , maybe, 2 ,ARM_THREAD_STATE64 );
  410. mach_error("thread_set_exception_ports:", kr);
  411. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_GUARD , maybe, 3 ,ARM_THREAD_STATE64 );
  412. mach_error("thread_set_exception_ports:", kr);
  413. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_RESOURCE, maybe, 1,7 );
  414. mach_error("thread_set_exception_ports:", kr);
  415. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_MACHINE, maybe, 2,5 );
  416.  
  417. mach_error("thread_set_exception_ports:", kr);
  418. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_SOFTWARE, maybe, 1,9 );
  419. mach_error("thread_set_exception_ports:", kr);
  420. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_EMULATION, maybe, 2,3 );
  421. mach_error("thread_set_exception_ports:", kr);
  422.  
  423. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_RPC_ALERT, maybe, 3,1 );
  424. mach_error("thread_set_exception_ports:", kr);
  425. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_BAD_INSTRUCTION, maybe, 1,0 );
  426. mach_error("thread_set_exception_ports:", kr);
  427. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1],EXC_MASK_ARITHMETIC, maybe, 3,0 );
  428. mach_error("thread_set_exception_ports:", kr);
  429. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1],EXC_MASK_MACH_SYSCALL, maybe, 3,9 );
  430. mach_error("thread_set_exception_ports:", kr);
  431. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1],EXC_MASK_BREAKPOINT, maybe, 3,8 );
  432. mach_error("thread_set_exception_ports:", kr);
  433. kr= thread_set_exception_ports(our_task_threads_corspe[thread_count-1],EXC_MASK_BAD_ACCESS, maybe, 1,2 );
  434. mach_error("thread_set_exception_ports:", kr);
  435.  
  436. kr = thread_get_exception_ports(our_task_threads_corspe[thread_count-1], EXC_MASK_ALL, aa.masks, &aa.count, aa.ports, aa.behaviors, aa.flavors);
  437. count_port =0;
  438. for (int i =0; i<14; i++) {
  439.  
  440. printf("0x%x\n", aa.ports[i]);
  441. if (maybe == aa.ports[i]) {
  442. printf("we got the port in the %d index\n", i);
  443. count_port++;
  444. }
  445.  
  446. }
  447. if (count_port > 1) {
  448. printf("same port in thread!\n");
  449. }
  450.  
  451.  
  452. kr = task_generate_corpse(corspe_task, e);
  453. mach_error("task_generate_corpse:", kr);
  454. kr = thread_get_exception_ports(c, EXC_MASK_ALL, aa.masks, &aa.count, aa.ports, aa.behaviors, aa.flavors);
  455. count_port =0;
  456. for (int i =0; i<14; i++) {
  457.  
  458. printf("0x%x\n", aa.ports[i]);
  459. if (maybe == aa.ports[i]) {
  460. printf("we got the port in the %d index\n", i);
  461. count_port++;
  462. }
  463.  
  464. }
  465. if (count_port > 1) {
  466. printf("same port in thread!\n");
  467. }
  468.  
  469. if (MACH_PORT_VALID(maybe)) {
  470. printf("worked?\n");
  471. }
  472.  
  473.  
  474. return 0;
  475.  
  476. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!