cscope.out

cscope 16 E:\GitHub\ChromeFuzzer               0000337574
	@E:\GitHub\ChromeFuzzer\PocSmplify\GrayHatPython-master\ghpython_src\src\addnum.cpp

1 
	~<¡dlib.h
>

2 
	~<¡dio.h
>

3 
	~<wšdows.h
>

5 
	$add_numb”
Ð
num1
, 
num2
 )

7 
sum
;

9 
sum
 = 
num1
 - 
num2
;

11  
sum
;

12 
	}
}

14 
	$maš
(
¬gc
, * 
¬gv
[])

16 
num1
, 
num2
;

17 
»tuº_v®ue
;

19 ifÐ
¬gc
 < 2 )

21 
	`´štf
("You‚eedoƒnterwo‚umberso‡dd.\n");

22 
	`´štf
("addnum.exe‚um1‚um2\n");

27 
num1
 = 
	`©oi
(
¬gv
[1]);

28 
num2
 = 
	`©oi
(
¬gv
[2]);

30 
»tuº_v®ue
 = 
	`add_numb”
Ð
num1
, 
num2
 );

32 
	`´štf
("Sum oà%d + %d = %d",
num1
, 
num2
, 
»tuº_v®ue
 );

35 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\GrayHatPython-master\ghpython_src\src\ghp_inject.cpp

2 
	~"¡dafx.h
"

4 
BOOL
 
APIENTRY
 
	$DÎMaš
Ð
HMODULE
 
hModuË
,

5 
DWORD
 
ul_»asÚ_fÜ_ÿÎ
,

6 
LPVOID
 
ÍRe£rved


9 
ul_»asÚ_fÜ_ÿÎ
)

11 
DLL_PROCESS_ATTACH
:

12 
	`Mes§geBoxA
(
NULL
,"H–lØäomh´oûss!","I‡m insidth´oûs you injeùed!",
MB_OK
);

13 
DLL_THREAD_ATTACH
:

14 
DLL_THREAD_DETACH
:

15 
DLL_PROCESS_DETACH
:

18  
TRUE
;

19 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\Exception.c

78 
	~<as£¹.h
>

79 
	~<¡dio.h
>

80 
	~<¡dlib.h
>

81 
	~<mach/mach.h
>

82 
	~<±h»ad.h
>

83 
	~<uni¡d.h
>

84 
	~<¡dboÞ.h
>

89 
	~"MachExû±iÚsS”v”.h
"

91 
	~"Exû±iÚ.h
"

92 
	~"im¶em’tiÚ.h
"

94 
	gth»ad_id
;

95 
	gexû±iÚ_code
;

96 
	gexû±iÚ_©
;

97 
	gexû±iÚ_»f
;

100 

	#EXCEPTION_ACCESS_VIOLATION
 0xC0000005

	)

101 

	#EXCEPTION_BREAKPOINT
 0x80000003

	)

102 

	#EXCEPTION_GUARD_PAGE
 0x80000001

	)

103 

	#EXCEPTION_SINGLE_STEP
 0x80000004

	)

104 

	#EFLAGS_TRAP
 0x00000100

	)

106 
	$XToWšExû±iÚ
(
ec
){

107 
»t
;

108 
ec
){

109 
EXC_BAD_ACCESS
:

110 
»t
 = 
EXCEPTION_ACCESS_VIOLATION
;

112 
EXC_BREAKPOINT
:

113 
»t
 = 
EXCEPTION_BREAKPOINT
;

115 
EXCEPTION_SINGLE_STEP
:

116 
»t
 = 
EXCEPTION_SINGLE_STEP
;

119 
»t
 = 
EXC_SOFTWARE
;

121  
»t
;

122 
	}
}

129 
k”n_»tuº_t
 
	$ÿtch_exû±iÚ_¿i£
(

130 
mach_pÜt_t
 
exû±iÚ_pÜt
,

131 
mach_pÜt_t
 
th»ad
,

132 
mach_pÜt_t
 
sk
,

133 
exû±iÚ_ty³_t
 
exû±iÚ
,

134 
exû±iÚ_d©a_t
 
code
,

135 
mach_msg_ty³_numb”_t
 
codeCÁ


138 
	`as£¹
(
çl£
);

139  
KERN_FAILURE
;

165 
	}
}

167 
k”n_»tuº_t
 
	$ÿtch_exû±iÚ_¿i£_¡©e
(

168 
mach_pÜt_t
 
exû±iÚ_pÜt
,

169 
exû±iÚ_ty³_t
 
exû±iÚ
,

170 cÚ¡ 
exû±iÚ_d©a_t
 
code
,

171 
mach_msg_ty³_numb”_t
 
codeCÁ
,

172 * 
æavÜ
,

173 cÚ¡ 
th»ad_¡©e_t
 
Þd_¡©e
,

174 
mach_msg_ty³_numb”_t
 
Þd_¡©eCÁ
,

175 
th»ad_¡©e_t
 
Ãw_¡©e
,

176 
mach_msg_ty³_numb”_t
 *
Ãw_¡©eCÁ


179 
	`as£¹
(
çl£
);

180  
KERN_FAILURE
;

181 
	}
}

183 
k”n_»tuº_t
 
	$ÿtch_exû±iÚ_¿i£_¡©e_id’t™y
(

184 
mach_pÜt_t
 
exû±iÚ_pÜt
,

185 
mach_pÜt_t
 
th»ad
,

186 
mach_pÜt_t
 
sk
,

187 
exû±iÚ_ty³_t
 
exû±iÚ
,

188 
exû±iÚ_d©a_t
 
code
,

189 
mach_msg_ty³_numb”_t
 
codeCÁ
,

190 * 
æavÜ
,

191 
th»ad_¡©e_t
 
Þd_¡©e
,

192 
mach_msg_ty³_numb”_t
 
Þd_¡©eCÁ
,

193 
th»ad_¡©e_t
 
Ãw_¡©e
,

194 
mach_msg_ty³_numb”_t
 *
Ãw_¡©eCÁ


263 
k”n_»tuº_t
 
»suÉ
;

264 
i
;

265 
i386_th»ad_¡©e_t
 * 
¡©e
;

273 
i
 = 0; i < 
codeCÁ
; i++) {

283 
	`as£¹
Ð
Þd_¡©eCÁ
 =ð
i386_THREAD_STATE_COUNT
 );

284 
¡©e
 = (
i386_th»ad_¡©e_t
 *è
Þd_¡©e
;

290 ià(
exû±iÚ
 =ð
EXC_BREAKPOINT
) {

291 
i386_th»ad_¡©e_t
 * 
ÃwS‹
;

297 
	`as£¹
Ð
Þd_¡©eCÁ
 <ð*
Ãw_¡©eCÁ
 );

298 *
Ãw_¡©eCÁ
 = 
Þd_¡©eCÁ
;

300 
ÃwS‹
 = (
i386_th»ad_¡©e_t
 *è
Ãw_¡©e
;

301 *
ÃwS‹
 = *
¡©e
;

303 
	`su¥’d_th»ad
(
th»ad
);

306 
th»ad_id
 = 
th»ad
;

307 
exû±iÚ_code
 = 
exû±iÚ
;

309 if(
¡©e
->
eæags
 & 
EFLAGS_TRAP
 || 
code
[0] =ð
EXC_I386_SGL
){

310 
exû±iÚ_code
 = 
EXCEPTION_SINGLE_STEP
;

312 
exû±iÚ_©
 = 
¡©e
->
e
 - 1;

313 
th»ad_¡©e_æavÜ_t
 
æavÜ
 = 
i386_EXCEPTION_STATE
;

314 
mach_msg_ty³_numb”_t
 
exc_¡©e_couÁ
 = 
i386_EXCEPTION_STATE_COUNT
;

315 
i386_exû±iÚ_¡©e_t
 
exc_¡©e
;

316 
	`th»ad_g‘_¡©e
(
th»ad
,
æavÜ
, (
Çtu¿l_t
*)&
exc_¡©e
, &
exc_¡©e_couÁ
);

317 
exû±iÚ_»f
 = 
exc_¡©e
.
çuÉvaddr
;

319 
»suÉ
 = 
KERN_SUCCESS
;

322 } ià(
exû±iÚ
 =ð
EXC_BAD_ACCESS
){

325 
th»ad_id
 = 
th»ad
;

326 
exû±iÚ_code
 = 
exû±iÚ
;

327 
exû±iÚ_©
 = 
¡©e
->
e
;

328 
th»ad_¡©e_æavÜ_t
 
æavÜ
 = 
i386_EXCEPTION_STATE
;

329 
mach_msg_ty³_numb”_t
 
exc_¡©e_couÁ
 = 
i386_EXCEPTION_STATE_COUNT
;

330 
i386_exû±iÚ_¡©e_t
 
exc_¡©e
;

331 
	`th»ad_g‘_¡©e
(
th»ad
,
æavÜ
, (
Çtu¿l_t
*)&
exc_¡©e
, &
exc_¡©e_couÁ
);

332 
exû±iÚ_»f
 = 
exc_¡©e
.
çuÉvaddr
;

333 
»suÉ
 = 
KERN_SUCCESS
;

338 
»suÉ
 = 
KERN_FAILURE
;

343  
»suÉ
;

344 
	}
}

346 

	#MAX_EXCEPTION_PORTS
 16

	)

349 
mach_msg_ty³_numb”_t
 
couÁ
;

350 
exû±iÚ_mask_t
 
masks
[
MAX_EXCEPTION_PORTS
];

351 
exû±iÚ_hªdËr_t
 
pÜts
[
MAX_EXCEPTION_PORTS
];

352 
exû±iÚ_behaviÜ_t
 
behaviÜs
[
MAX_EXCEPTION_PORTS
];

353 
th»ad_¡©e_æavÜ_t
 
æavÜs
[
MAX_EXCEPTION_PORTS
];

354 } 
Þd_exc_pÜts
;

356 
mach_pÜt_t
 
	$š™
(
pid
){

357 
mach_pÜt_t
 * 
exû±iÚPÜt
 = 
	`m®loc
((mach_port_t));

358 
mach_pÜt_t
 
me
;

359 
sk_t
 
rg‘Task
;

360 
exû±iÚ_mask_t
 
mask
 = 
EXC_MASK_BAD_ACCESS
 | 
EXC_MASK_BAD_INSTRUCTION
 | 
EXC_MASK_ARITHMETIC
 | 
EXC_MASK_SOFTWARE
 | 
EXC_MASK_BREAKPOINT
 | 
EXC_MASK_SYSCALL
;

368 
me
 = 
	`mach_sk_£lf
();

369 
	`mach_pÜt_®loÿ‹
(
me
, 
MACH_PORT_RIGHT_RECEIVE
, 
exû±iÚPÜt
);

370 
	`mach_pÜt_š£¹_right
(
me
, *
exû±iÚPÜt
, *exû±iÚPÜt, 
MACH_MSG_TYPE_MAKE_SEND
);

373 if(
	`sk_fÜ_pid
(
me
, 
pid
, &
rg‘Task
)!=
KERN_SUCCESS
){

379 
	`sk_g‘_exû±iÚ_pÜts
(
rg‘Task
, 
mask
, 
Þd_exc_pÜts
.
masks
, &Þd_exc_pÜts.
couÁ
, old_exc_pÜts.
pÜts
, old_exc_pÜts.
behaviÜs
, old_exc_pÜts.
æavÜs
);

382 
	`sk_£t_exû±iÚ_pÜts
(
rg‘Task
, 
mask
, *
exû±iÚPÜt
, 
EXCEPTION_STATE_IDENTITY
, 
i386_THREAD_STATE
);

385  *
exû±iÚPÜt
;

386 
	}
}

392 
mach_msg_h—d”_t
 
	mh—d
;

393 
	md©a
[256];

394 } 
	gȦy
;

397 
mach_msg_h—d”_t
 
	mh—d
;

398 
mach_msg_body_t
 
	mmsgh_body
;

399 
	md©a
[1024];

400 } 
	gmsg
;

403 
	$my_msg_£rv”
(
mach_pÜt_t
 
exû±iÚ_pÜt
, 
mžli£cÚds
, *
id
, *
ec
, *
—t
, *
”ef
){

404 
mach_msg_»tuº_t
 
r
;

406 
r
 = 
	`mach_msg
(&
msg
.
h—d
,

407 
MACH_RCV_MSG
|
MACH_RCV_LARGE
|
MACH_RCV_TIMEOUT
,

409 (
msg
),

410 
exû±iÚ_pÜt
,

411 
mžli£cÚds
,

412 
MACH_PORT_NULL
);

414 if(
r
 =ð
MACH_RCV_TIMED_OUT
){

416 } if(
r
 !ð
MACH_MSG_SUCCESS
){

422 if(!
	`exc_£rv”
(&
msg
.
h—d
,&
Ȧy
.head)){

427 *
id
 = 
th»ad_id
;

428 *
ec
 = 
	`XToWšExû±iÚ
(
exû±iÚ_code
);

429 *
—t
 = 
exû±iÚ_©
;

430 *
”ef
 = 
exû±iÚ_»f
;

434 
r
 = 
	`mach_msg
(

435 &
Ȧy
.
h—d
,

436 
MACH_SEND_MSG
|
MACH_SEND_TIMEOUT
,

437 
Ȧy
.
h—d
.
msgh_size
,

439 
MACH_PORT_NULL
,

440 
mžli£cÚds
,

441 
MACH_PORT_NULL
);

443 if(
r
 =ð
MACH_SEND_TIMED_OUT
){

445 } if(
r
 !ð
MACH_MSG_SUCCESS
){

451 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\Exception.h

10 
my_msg_£rv”
(
mach_pÜt_t
 
exû±iÚ_pÜt
, 
mžli£cÚds
, *
id
, *
ec
, *
—t
, *
”ef
);

11 
ÿÎ_msg_£rv”
(
mach_pÜt_t
 
exû±iÚPÜt
);

12 
mach_pÜt_t
 
š™
(
pid
);

13 
XToWšExû±iÚ
(
ec
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\MacDll.c

1 
	~<¡dio.h
>

2 
	~<sys/ty³s.h
>

3 
	~<sys/¡©.h
>

4 
	~<sys/±¿û.h
>

5 
	~<¡dio.h
>

7 
	~"MacDÎ.h
"

8 
	~"dyld.h
"

10 

	#EXPORT
 
	`__©Œibu‹__
((
	`visibž™y
("deçuÉ")))

	)

13 
mach_pÜt_t
 
	gexû±iÚ_pÜt
;

14 
	gcu¼’t_pid
;

15 
BOOL
 
	gkžl_Ú_ex™
;

16 
kšfo_´oc
 *
	gkšfo
;

17 
	gkšfo_max
;

18 
	gkšfo_cur
;

19 
th»ad_aù_pÜt_¬¿y_t
 
	gth»ad_li¡
;

20 
mach_msg_ty³_numb”_t
 
	gth»ad_max
;

21 
	gth»ad_cur
;

22 
	g®loÿ‹d_fs_ba£
;

26 
__©Œibu‹__
((
cÚ¡ruùÜ
))

27 
	$š™Ÿliz”
() {

28 
kšfo
 = 0;

29 
®loÿ‹d_fs_ba£
 = 0;

31 
	}
}

34 
__©Œibu‹__
((
de¡ruùÜ
))

35 
	$fš®iz”
() {

37 
	}
}

39 
EXPORT


40 
	$G‘Sy¡emInfo
(
LPSYSTEM_INFO
 
ÍSy¡emInfo
){

41 
ho¡_Çme_pÜt_t
 
myho¡
;

42 
ho¡_basic_šfo_d©a_t
 
hšfo
;

43 
vm_size_t
 
·ge_size
;

44 
mach_msg_ty³_numb”_t
 
couÁ
;

46 
myho¡
 = 
	`mach_ho¡_£lf
();

47 
couÁ
 = 
HOST_BASIC_INFO_COUNT
;

48 
	`ho¡_šfo
(
myho¡
, 
HOST_BASIC_INFO
, (
ho¡_šfo_t
è&
hšfo
, &
couÁ
);

49 
	`ho¡_·ge_size
(
myho¡
, &
·ge_size
);

51 
ÍSy¡emInfo
->
dwPageSize
 = 
·ge_size
;

52 
ÍSy¡emInfo
->
dwNumb”OfProûssÜs
 = 
hšfo
.
avaž_ýus
;

54 
	}
}

56 
EXPORT


57 
BOOL
 
	$Clo£HªdË
(
HANDLE
 
hObjeù
){

58 if(
kšfo
){

59 
	`ä“
(
kšfo
);

60 
kšfo
 = 0;

65 
	}
}

67 
EXPORT


68 
BOOL
 
	$DebugAùiveProûss
(
DWORD
 
dwProûssId
){

69 
kžl_Ú_ex™
 = 0;

70 
cu¼’t_pid
 = 
dwProûssId
;

73 
kšfo
 = 0;

74 
®loÿ‹d_fs_ba£
 = 0;

76  
	`©ch
(
dwProûssId
, &
exû±iÚ_pÜt
);

77 
	}
}

79 
EXPORT


80 
BOOL
 
	$Wa™FÜDebugEv’t
(
LPDEBUG_EVENT
 
ÍDebugEv’t
, 
DWORD
 
dwMžli£cÚds
){

81 
»t
, 
ec
, 
id
;

82 
—t
, 
”ef
;

83 
»t
 = 
	`my_msg_£rv”
(
exû±iÚ_pÜt
, 
dwMžli£cÚds
, &
id
, &
ec
, &
—t
, &
”ef
);

85 
ÍDebugEv’t
->
dwTh»adId
 = 
id
;

86 
ÍDebugEv’t
->
dwDebugEv’tCode
 = 
EXCEPTION_DEBUG_EVENT
;

87 
ÍDebugEv’t
->
u
.
Exû±iÚ
.
Exû±iÚRecÜd
.
Exû±iÚCode
 = 
ec
;

88 
ÍDebugEv’t
->
u
.
Exû±iÚ
.
Exû±iÚRecÜd
.
Exû±iÚAdd»ss
 = 
—t
;

89 
ÍDebugEv’t
->
u
.
Exû±iÚ
.
Exû±iÚRecÜd
.
Exû±iÚInfÜm©iÚ
[0] = 0;

90 
ÍDebugEv’t
->
u
.
Exû±iÚ
.
Exû±iÚRecÜd
.
Exû±iÚInfÜm©iÚ
[1] = (
ULONG_PTR
è
”ef
;

91 
ÍDebugEv’t
->
dwProûssId
 = 0;

93  
»t
;

94 
	}
}

96 
EXPORT


97 
BOOL
 
	$CÚtšueDebugEv’t
(
DWORD
 
dwProûssId
, DWORD 
dwTh»adId
, DWORD 
dwCÚtšueStus
){

98 
i386_th»ad_¡©e_t
 
¡©e
;

99 
	`g‘_cÚ‹xt
(
dwTh»adId
, &
¡©e
);

100  
	`»sume_th»ad
(
dwTh»adId
);

101 
	}
}

103 
EXPORT


104 
BOOL
 
	$DebugS‘ProûssKžlOnEx™
(
BOOL
 
KžlOnEx™
){

105 
kžl_Ú_ex™
 = 
KžlOnEx™
;

107 
	}
}

109 
EXPORT


110 
BOOL
 
	$DebugAùiveProûssStÝ
(
DWORD
 
dwProûssId
){

111 
»t
 = 
	`d‘ach
(
dwProûssId
, &
exû±iÚ_pÜt
);

112 if(
kžl_Ú_ex™
){

113 
	`T”mš©eProûss
(
dwProûssId
, 0);

115  
»t
;

116 
	}
}

118 
EXPORT


119 
BOOL
 
	$T”mš©eProûss
(
HANDLE
 
hProûss
, 
UINT
 
uEx™Code
){

120 
¡s
 = 
	`kžl
(
hProûss
, 9);

122 
¡s
++;

123  
¡s
;

124 
	}
}

126 
EXPORT


127 
HANDLE
 
	$C»©eToÞh–p32SÇpshÙ
(
DWORD
 
dwFÏgs
, DWORD 
th32ProûssID
){

129 
ùl
[4] = {0};

130 
size
 = 0;

133 
ùl
[0] = 
CTL_KERN
;

134 
ùl
[1] = 
KERN_PROC
;

135 
ùl
[2] = 
KERN_PROC_ALL
;

136 
	`sysùl
(
ùl
, 3, 
NULL
, (
size_t
 *è&
size
, NULL, 0);

137 
kšfo
 = 
	`ÿÎoc
(1, 
size
);

138 
	`sysùl
(
ùl
, 3, 
kšfo
, (
size_t
 *è&
size
, 
NULL
, 0);

139 
kšfo_max
 = 
size
 / (
kšfo_´oc
);

140 
kšfo_cur
 = 0;

143 
	`g‘_sk_th»ads
(
th32ProûssID
, &
th»ad_li¡
, &
th»ad_max
);

144 
th»ad_cur
 = 0;

147 
	}
}

149 
EXPORT


150 
BOOL
 
	$Th»ad32Fœ¡
(
HANDLE
 
hSÇpshÙ
, 
LPTHREADENTRY32
 
Í‹
){

151 if(
th»ad_cur
 < 
th»ad_max
){

152 
Í‹
->
th32Th»adID
 = 
th»ad_li¡
[
th»ad_cur
];

153 
Í‹
->
th32OwÃrProûssID
 = 
cu¼’t_pid
;

154 
th»ad_cur
++;

159 
	}
}

161 
EXPORT


162 
BOOL
 
	$Th»ad32Next
(
HANDLE
 
hSÇpshÙ
, 
LPTHREADENTRY32
 
Í‹
){

163 if(
th»ad_cur
 < 
th»ad_max
){

164 
Í‹
->
th32Th»adID
 = 
th»ad_li¡
[
th»ad_cur
];

165 
Í‹
->
th32OwÃrProûssID
 = 
cu¼’t_pid
;

166 
th»ad_cur
++;

171 
	}
}

173 
EXPORT


174 
BOOL
 
	$Proûss32Fœ¡
(
HANDLE
 
hSÇpshÙ
, 
LPPROCESSENTRY32
 
ͳ
){

175 if(
kšfo_cur
 < 
kšfo_max
){

176 
ͳ
->
th32ProûssID
 = 
kšfo
[
kšfo_cur
].
kp_´oc
.
p_pid
;

177 
	`¡ºýy
(
ͳ
->
szExeFže
, 
kšfo
[
kšfo_cur
].
kp_´oc
.
p_comm
, 
MAX_PATH
-1);

178 
ͳ
->
szExeFže
[
MAX_PATH
-1] = 0;

179 
kšfo_cur
++;

184 
	}
}

186 
EXPORT


187 
BOOL
 
	$Proûss32Next
(
HANDLE
 
hSÇpshÙ
, 
LPPROCESSENTRY32
 
ͳ
){

188 if(
kšfo_cur
 < 
kšfo_max
){

189 
ͳ
->
th32ProûssID
 = 
kšfo
[
kšfo_cur
].
kp_´oc
.
p_pid
;

190 
	`¡ºýy
(
ͳ
->
szExeFže
, 
kšfo
[
kšfo_cur
].
kp_´oc
.
p_comm
, 
MAX_PATH
-1);

191 
ͳ
->
szExeFže
[
MAX_PATH
-1] = 0;

192 
kšfo_cur
++;

197 
	}
}

199 
EXPORT


200 
BOOL
 
	$G‘Th»adCÚ‹xt
(
HANDLE
 
hTh»ad
, 
LPCONTEXT
 
ÍCÚ‹xt
){

201 
mach_msg_ty³_numb”_t
 
sc
;

203 
i386_th»ad_¡©e_t
 
¡©e
;

204 
sc
 = 
i386_THREAD_STATE_COUNT
;

205 
	`th»ad_g‘_¡©e
Ð
hTh»ad
, 
i386_THREAD_STATE
, (
th»ad_¡©e_t
è&
¡©e
, &
sc
);

206 
ÍCÚ‹xt
->
Eax
 = 
¡©e
.
—x
;

207 
ÍCÚ‹xt
->
Ebx
 = 
¡©e
.
ebx
;

208 
ÍCÚ‹xt
->
Ecx
 = 
¡©e
.
ecx
;

209 
ÍCÚ‹xt
->
Edx
 = 
¡©e
.
edx
;

210 
ÍCÚ‹xt
->
Edi
 = 
¡©e
.
edi
;

211 
ÍCÚ‹xt
->
Esi
 = 
¡©e
.
esi
;

212 
ÍCÚ‹xt
->
Ebp
 = 
¡©e
.
ebp
;

213 
ÍCÚ‹xt
->
E¥
 = 
¡©e
.
e¥
;

214 
ÍCÚ‹xt
->
SegSs
 = 
¡©e
.
ss
;

215 
ÍCÚ‹xt
->
EFÏgs
 = 
¡©e
.
eæags
;

216 
ÍCÚ‹xt
->
E
 = 
¡©e
.
e
;

217 
ÍCÚ‹xt
->
SegCs
 = 
¡©e
.
cs
;

218 
ÍCÚ‹xt
->
SegDs
 = 
¡©e
.
ds
;

219 
ÍCÚ‹xt
->
SegEs
 = 
¡©e
.
es
;

220 
ÍCÚ‹xt
->
SegFs
 = 
¡©e
.
fs
;

221 
ÍCÚ‹xt
->
SegGs
 = 
¡©e
.
gs
;

223 
x86_debug_¡©e32_t
 
debug
;

224 
sc
 = 
x86_DEBUG_STATE32_COUNT
;

225 
	`th»ad_g‘_¡©e
Ð
hTh»ad
, 
x86_DEBUG_STATE32
, (
th»ad_¡©e_t
è&
debug
, &
sc
);

226 
ÍCÚ‹xt
->
Dr0
 = 
debug
.
dr0
;

227 
ÍCÚ‹xt
->
Dr1
 = 
debug
.
dr1
;

228 
ÍCÚ‹xt
->
Dr2
 = 
debug
.
dr2
;

229 
ÍCÚ‹xt
->
Dr3
 = 
debug
.
dr3
;

230 
ÍCÚ‹xt
->
Dr6
 = 
debug
.
dr6
;

231 
ÍCÚ‹xt
->
Dr7
 = 
debug
.
dr7
;

234 
	}
}

236 
EXPORT


237 
BOOL
 
	$S‘Th»adCÚ‹xt
(
HANDLE
 
hTh»ad
, cÚ¡ 
CONTEXT
* 
ÍCÚ‹xt
){

238 
mach_msg_ty³_numb”_t
 
sc
;

239 
k”n_»tuº_t
 
»suÉ
;

241 
i386_th»ad_¡©e_t
 
¡©e
;

242 
¡©e
.
—x
 = 
ÍCÚ‹xt
->
Eax
;

243 
¡©e
.
ebx
 = 
ÍCÚ‹xt
->
Ebx
;

244 
¡©e
.
ecx
 = 
ÍCÚ‹xt
->
Ecx
;

245 
¡©e
.
edx
 = 
ÍCÚ‹xt
->
Edx
;

246 
¡©e
.
edi
 = 
ÍCÚ‹xt
->
Edi
;

247 
¡©e
.
esi
 = 
ÍCÚ‹xt
->
Esi
;

248 
¡©e
.
ebp
 = 
ÍCÚ‹xt
->
Ebp
;

249 
¡©e
.
e¥
 = 
ÍCÚ‹xt
->
E¥
;

250 
¡©e
.
ss
 = 
ÍCÚ‹xt
->
SegSs
;

251 
¡©e
.
eæags
 = 
ÍCÚ‹xt
->
EFÏgs
;

252 
¡©e
.
e
 = 
ÍCÚ‹xt
->
E
;

253 
¡©e
.
cs
 = 
ÍCÚ‹xt
->
SegCs
;

254 
¡©e
.
ds
 = 
ÍCÚ‹xt
->
SegDs
;

255 
¡©e
.
es
 = 
ÍCÚ‹xt
->
SegEs
;

256 
¡©e
.
fs
 = 
ÍCÚ‹xt
->
SegFs
;

257 
¡©e
.
gs
 = 
ÍCÚ‹xt
->
SegGs
;

258 
sc
 = 
i386_THREAD_STATE_COUNT
;

259 
»suÉ
 = 
	`th»ad_£t_¡©e
Ð
hTh»ad
, 
i386_THREAD_STATE
, (
th»ad_¡©e_t
è&
¡©e
, 
sc
);

260 if(
»suÉ
 !ð
KERN_SUCCESS
){

264 
x86_debug_¡©e32_t
 
debug
;

265 
debug
.
dr0
 = 
ÍCÚ‹xt
->
Dr0
;

266 
debug
.
dr1
 = 
ÍCÚ‹xt
->
Dr1
;

267 
debug
.
dr2
 = 
ÍCÚ‹xt
->
Dr2
;

268 
debug
.
dr3
 = 
ÍCÚ‹xt
->
Dr3
;

269 
debug
.
dr6
 = 
ÍCÚ‹xt
->
Dr6
;

270 
debug
.
dr7
 = 
ÍCÚ‹xt
->
Dr7
;

271 
sc
 = 
x86_DEBUG_STATE32_COUNT
;

272 
»suÉ
 = 
	`th»ad_£t_¡©e
Ð
hTh»ad
, 
x86_DEBUG_STATE32
, (
th»ad_¡©e_t
è&
debug
, 
sc
);

273 if(
»suÉ
 !ð
KERN_SUCCESS
){

278 
	}
}

280 
EXPORT


281 
BOOL
 
	$C»©eProûssA
(
LPCTSTR
 
ÍAµliÿtiÚName
, 
LPTSTR
 
ÍCommªdLše
, 
LPSECURITY_ATTRIBUTES
 
ÍProûssA‰ribu‹s
, LPSECURITY_ATTRIBUTES 
ÍTh»adA‰ribu‹s
, 
BOOL
 
bInh”™HªdËs
, 
DWORD
 
dwC»©iÚFÏgs
, 
LPVOID
 
ÍEnvœÚm’t
, LPCTSTR 
ÍCu¼’tDœeùÜy
, 
LPSTARTUPINFO
 
ÍS¹upInfo
, 
LPPROCESS_INFORMATION
 
ÍProûssInfÜm©iÚ
){

282 
pid_t
 
pid
 = 
	`vfÜk
();

284 if(
pid
 == 0){

285 
commªdlše
[256];

286 
	`¡ºýy
(
commªdlše
, 
ÍCommªdLše
, 255);

287 
commªdlše
[255] = 0;

290 
i
=0;

291 *
p
 = 
	`¡rchr
(
commªdlše
, ' ');

292 *
q
 = 
commªdlše
;

293 *
¬gv
[16];

294 
p
){

295 *
p
 = 0;

296 
¬gv
[
i
++] = 
q
;

297 
	`fæush
(
¡dout
);

298 
q
 = 
p
 + 1;

299 
p
 = 
	`¡rchr
(
commªdlše
, ' ');

301 
¬gv
[
i
] = 
q
;

302 
¬gv
[
i
+1] = 0;

304 
	`fæush
(
¡dout
);

305 
	`execv
(
¬gv
[0],‡rgv);

306 
	`³¼Ü
("Failedoƒxecv!");

308 
	`DebugAùiveProûss
(
pid
);

311 
ÍProûssInfÜm©iÚ
->
dwProûssId
 = 
pid
;

312 
ÍProûssInfÜm©iÚ
->
hProûss
 = 
pid
;

315 
	}
}

317 
EXPORT


318 
HANDLE
 
	$O³nProûss
(
DWORD
 
dwDesœedAcûss
, 
BOOL
 
bInh”™HªdË
, DWORD 
dwProûssId
){

319  
dwProûssId
;

320 
	}
}

322 
EXPORT


323 
HANDLE
 
	$O³nTh»ad
(
DWORD
 
dwDesœedAcûss
, 
BOOL
 
bInh”™HªdË
, DWORD 
dwTh»adId
){

324  
dwTh»adId
;

325 
	}
}

327 
EXPORT


328 
BOOL
 
	$R—dProûssMemÜy
(
HANDLE
 
hProûss
, 
LPCVOID
 
ÍBa£Add»ss
, 
LPVOID
 
ÍBufãr
, 
SIZE_T
 
nSize
, SIZE_T* 
ÍNumb”OfBy‹sR—d
){

329 
¡s
;

330 
¡s
 = 
	`»ad_memÜy
(
hProûss
, (è
ÍBa£Add»ss
, 
nSize
, 
ÍBufãr
);

331 *
ÍNumb”OfBy‹sR—d
 = 
nSize
;

332  
¡s
;

333 
	}
}

335 
EXPORT


336 
BOOL
 
	$Wr™eProûssMemÜy
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍBa£Add»ss
, 
LPCVOID
 
ÍBufãr
, 
SIZE_T
 
nSize
, SIZE_T* 
ÍNumb”OfBy‹sWr™‹n
){

337 
¡s
 = 
	`wr™e_memÜy
(
hProûss
, (è
ÍBa£Add»ss
, 
nSize
, (*è
ÍBufãr
);

338 *
ÍNumb”OfBy‹sWr™‹n
 = 
nSize
;

339  
¡s
;

340 
	}
}

342 
EXPORT


343 
DWORD
 
	$ResumeTh»ad
(
HANDLE
 
hTh»ad
){

344  
	`»sume_th»ad
(
hTh»ad
);

345 
	}
}

347 
EXPORT


348 
DWORD
 
	$Su¥’dTh»ad
(
HANDLE
 
hTh»ad
){

349  
	`su¥’d_th»ad
(
hTh»ad
);

350 
	}
}

353 
EXPORT


354 
LPVOID
 
	$Vœtu®AÎocEx
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍAdd»ss
, 
SIZE_T
 
dwSize
, 
DWORD
 
æAÎoÿtiÚTy³
, DWORD 
æPrÙeù
){

356 
addy
 = (è
	`®loÿ‹
(
hProûss
, (è
ÍAdd»ss
, 
dwSize
);

357  (
LPVOID
è
addy
;

358 
	}
}

360 
EXPORT


361 
BOOL
 
	$Vœtu®F»eEx
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍAdd»ss
, 
SIZE_T
 
dwSize
, 
DWORD
 
dwF»eTy³
){

362  
	`vœtu®_ä“
(
hProûss
, (è
ÍAdd»ss
, 
dwSize
);

363 
	}
}

365 
EXPORT


366 
SIZE_T
 
	$Vœtu®Qu”yEx
(
HANDLE
 
hProûss
, 
LPCVOID
 
ÍAdd»ss
, 
PMEMORY_BASIC_INFORMATION
 
ÍBufãr
, 
SIZE_T
 
dwL’gth
){

367 
addr
, 
´Ù
, 
size
 = 0;

368 
addr
 = (è
ÍAdd»ss
;

370 if(
	`vœtu®_qu”y
(
hProûss
, &
addr
, &
´Ù
, &
size
)){

374 
ÍBufãr
->
Ba£Add»ss
 = 
addr
;

375 
ÍBufãr
->
PrÙeù
 = 
´Ù
;

376 
ÍBufãr
->
RegiÚSize
 = 
size
;

377 
ÍBufãr
->
S‹
 = 
MEM_COMMIT
;

379  (
MEMORY_BASIC_INFORMATION
);

380 
	}
}

382 
EXPORT


383 
DWORD
 
	$G‘FžeSize
(
HANDLE
 
hFže
, 
LPDWORD
 
ÍFžeSizeHigh
){

384 
¡©
 
sb
;

385 
	`f¡©
(
hFže
, &
sb
);

386  
sb
.
¡_size
;

387 
	}
}

389 
EXPORT


390 
BOOL
 
	$Vœtu®PrÙeùEx
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍAdd»ss
, 
SIZE_T
 
dwSize
, 
DWORD
 
æNewPrÙeù
, 
PDWORD
 
ÍæOldPrÙeù
){

392 
MEMORY_BASIC_INFORMATION
 
Bufãr
;

393 
	`Vœtu®Qu”yEx
(
hProûss
, 
ÍAdd»ss
, &
Bufãr
, 
dwSize
);

394 *
ÍæOldPrÙeù
 = 
Bufãr
.
PrÙeù
;

396  
	`vœtu®_´Ùeù
(
hProûss
, (è
ÍAdd»ss
, 
dwSize
, 
æNewPrÙeù
);

397 
	}
}

399 
EXPORT


400 
BOOL
 
	$G‘Th»adS–eùÜEÁry
(
HANDLE
 
hTh»ad
, 
DWORD
 
dwS–eùÜ
, 
LPLDT_ENTRY
 
ÍS–eùÜEÁry
){

407 if(!
®loÿ‹d_fs_ba£
){

408 *
çke_d©a
 = (*è
	`m®loc
(0x40);

411 
®loÿ‹d_fs_ba£
 = (è
	`®loÿ‹
(
hTh»ad
, 0, 128);

412 if(!
®loÿ‹d_fs_ba£
){

416 
	`vœtu®_´Ùeù
(
hTh»ad
, 
®loÿ‹d_fs_ba£
, 128, 
PAGE_READWRITE
);

418 
	`mem£t
(
çke_d©a
, 0x0, 0x40);

419 
	`memýy
(
çke_d©a
, "\xff\xff\xff\xff"

423 *
p
 = (*è(
çke_d©a
 + 0x30);

424 *
p
 = 
	`htÚl
(
®loÿ‹d_fs_ba£
);

425 
	`wr™e_memÜy
(
hTh»ad
, 
®loÿ‹d_fs_ba£
, 0x40, 
çke_d©a
);

428 
ÍS–eùÜEÁry
->
Ba£Low
 = 
®loÿ‹d_fs_ba£
 & 0xffff;

429 
ÍS–eùÜEÁry
->
HighWÜd
.
By‹s
.
Ba£Mid
 = (
®loÿ‹d_fs_ba£
 & 0xff0000) >> 16;

430 
ÍS–eùÜEÁry
->
HighWÜd
.
By‹s
.
Ba£Hi
 = (
®loÿ‹d_fs_ba£
 & 0xff000000) >> 24;

433 
	}
}

437 
EXPORT


438 
HMODULE
 
	$LßdLib¿ryA
(
LPCTSTR
 
ÍFžeName
){

440 
	}
}

442 
EXPORT


443 
BOOL
 
	$F»eLib¿ry
(
HMODULE
 
hModuË
){

445 
	}
}

447 
EXPORT


448 
FARPROC
 
	$G‘ProcAdd»ss
(
HMODULE
 
hModuË
, 
LPCSTR
 
ÍProcName
){

450 
	}
}

452 
EXPORT


453 
BOOL
 
	$FlushIn¡ruùiÚCache
(
HANDLE
 
hProûss
, 
LPCVOID
 
ÍBa£Add»ss
, 
SIZE_T
 
dwSize
){

455 
	}
}

458 
EXPORT


459 
BOOL
 
	$ModuË32Fœ¡
(
HANDLE
 
hSÇpshÙ
, 
LPMODULEENTRY32
 
Íme
){

461 
	}
}

463 
EXPORT


464 
BOOL
 
	$ModuË32Next
(
HANDLE
 
hSÇpshÙ
, 
LPMODULEENTRY32
 
Íme
){

466 
	}
}

468 
EXPORT


469 
HANDLE
 
	$G‘Cu¼’tProûss
(){

471 
	}
}

473 
EXPORT


474 
DWORD
 
	$G‘La¡E¼Ü
(){

476 
	}
}

478 
EXPORT


479 
DWORD
 
	$FÜm©Mes§geA
(
DWORD
 
dwFÏgs
, 
LPCVOID
 
ÍSourû
, DWORD 
dwMes§geId
, DWORD 
dwLªguageId
, 
LPTSTR
 
ÍBufãr
, DWORD 
nSize
, 
va_li¡
* 
Argum’ts
){

481 
	`ex™
(1);

482 
	}
}

484 
EXPORT


485 
HANDLE
 
	$C»©eFžeM­pšgA
(
HANDLE
 
hFže
, 
LPSECURITY_ATTRIBUTES
 
ÍA‰ribu‹s
, 
DWORD
 
æPrÙeù
, DWORD 
dwMaximumSizeHigh
, DWORD 
dwMaximumSizeLow
, 
LPCTSTR
 
ÍName
){

487 
	}
}

489 
EXPORT


490 
LPVOID
 
	$M­V›wOfFže
(
HANDLE
 
hFžeM­pšgObjeù
, 
DWORD
 
dwDesœedAcûss
, DWORD 
dwFžeOff£tHigh
, DWORD 
dwFžeOff£tLow
, 
SIZE_T
 
dwNumb”OfBy‹sToM­
){

492 
	}
}

494 
EXPORT


495 
DWORD
 
	$G‘M­³dFžeName
(
HANDLE
 
hProûss
, 
LPVOID
 
Ív
, 
LPTSTR
 
ÍFž’ame
, 
DWORD
 
nSize
){

497 
	}
}

499 
EXPORT


500 
BOOL
 
	$Unm­V›wOfFže
(
LPCVOID
 
ÍBa£Add»ss
){

502 
	}
}

504 
EXPORT


505 
BOOL
 
	$O³nProûssTok’
(
HANDLE
 
ProûssHªdË
, 
DWORD
 
DesœedAcûss
, 
PHANDLE
 
Tok’HªdË
){

507 
	}
}

509 
EXPORT


510 
BOOL
 
	$LookupPrivžegeV®ueA
(
LPCTSTR
 
ÍSy¡emName
, LPCTSTR 
ÍName
, 
PLUID
 
ÍLuid
){

512 
	}
}

514 
EXPORT


515 
BOOL
 
	$Adju¡Tok’Privžeges
(
HANDLE
 
Tok’HªdË
, 
BOOL
 
Di§bËAÎPrivžeges
, 
PTOKEN_PRIVILEGES
 
NewS‹
, 
DWORD
 
BufãrL’gth
, PTOKEN_PRIVILEGES 
P»viousS‹
, 
PDWORD
 
R‘uºL’gth
){

517 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\MacDll.h

10 
	~<mach/mach.h
>

11 
	~"wšdows.h
"

12 
	~"im¶em’tiÚ.h
"

13 
	~"Exû±iÚ.h
"

14 
	~<sigÇl.h
>

15 
	~<¡dlib.h
>

16 
	~<¡dio.h
>

17 
	~<mach/mach_Œ­s.h
>

18 
	~<mach/mach_ty³s.h
>

19 
	~<¡ršg.h
>

20 
	~<mach/th»ad_¡©us.h
>

21 
	~<uni¡d.h
>

22 
	~<mach/mach.h
>

23 
	~<sys/ty³s.h
>

24 
	~<sys/sysùl.h
>

29 
G‘Sy¡emInfo
(
LPSYSTEM_INFO
 
ÍSy¡emInfo
);

30 
BOOL
 
Clo£HªdË
(
HANDLE
 
hObjeù
);

31 
BOOL
 
DebugAùiveProûss
(
DWORD
 
dwProûssId
);

32 
BOOL
 
Wa™FÜDebugEv’t
(
LPDEBUG_EVENT
 
ÍDebugEv’t
, 
DWORD
 
dwMžli£cÚds
);

33 
BOOL
 
CÚtšueDebugEv’t
(
DWORD
 
dwProûssId
, DWORD 
dwTh»adId
, DWORD 
dwCÚtšueStus
);

34 
BOOL
 
DebugS‘ProûssKžlOnEx™
(BOOL 
KžlOnEx™
);

35 
BOOL
 
DebugAùiveProûssStÝ
(
DWORD
 
dwProûssId
);

36 
BOOL
 
T”mš©eProûss
(
HANDLE
 
hProûss
, 
UINT
 
uEx™Code
);

37 
HANDLE
 
C»©eToÞh–p32SÇpshÙ
(
DWORD
 
dwFÏgs
, DWORD 
th32ProûssID
);

38 
BOOL
 
Proûss32Fœ¡
(
HANDLE
 
hSÇpshÙ
, 
LPPROCESSENTRY32
 
ͳ
);

39 
BOOL
 
Proûss32Next
(
HANDLE
 
hSÇpshÙ
, 
LPPROCESSENTRY32
 
ͳ
);

40 
BOOL
 
Th»ad32Fœ¡
(
HANDLE
 
hSÇpshÙ
, 
LPTHREADENTRY32
 
Í‹
);

41 
BOOL
 
Th»ad32Next
(
HANDLE
 
hSÇpshÙ
, 
LPTHREADENTRY32
 
Í‹
);

42 
BOOL
 
G‘Th»adCÚ‹xt
(
HANDLE
 
hTh»ad
, 
LPCONTEXT
 
ÍCÚ‹xt
);

43 
BOOL
 
C»©eProûssA
(
LPCTSTR
 
ÍAµliÿtiÚName
, 
LPTSTR
 
ÍCommªdLše
, 
LPSECURITY_ATTRIBUTES
 
ÍProûssA‰ribu‹s
, LPSECURITY_ATTRIBUTES 
ÍTh»adA‰ribu‹s
, BOOL 
bInh”™HªdËs
, 
DWORD
 
dwC»©iÚFÏgs
, 
LPVOID
 
ÍEnvœÚm’t
, LPCTSTR 
ÍCu¼’tDœeùÜy
, 
LPSTARTUPINFO
 
ÍS¹upInfo
, 
LPPROCESS_INFORMATION
 
ÍProûssInfÜm©iÚ
);

44 
HANDLE
 
O³nProûss
(
DWORD
 
dwDesœedAcûss
, 
BOOL
 
bInh”™HªdË
, DWORD 
dwProûssId
);

45 
HANDLE
 
O³nTh»ad
(
DWORD
 
dwDesœedAcûss
, 
BOOL
 
bInh”™HªdË
, DWORD 
dwTh»adId
);

46 
BOOL
 
R—dProûssMemÜy
(
HANDLE
 
hProûss
, 
LPCVOID
 
ÍBa£Add»ss
, 
LPVOID
 
ÍBufãr
, 
SIZE_T
 
nSize
, SIZE_T* 
ÍNumb”OfBy‹sR—d
);

47 
DWORD
 
ResumeTh»ad
(
HANDLE
 
hTh»ad
);

48 
BOOL
 
S‘Th»adCÚ‹xt
(
HANDLE
 
hTh»ad
, cÚ¡ 
CONTEXT
* 
ÍCÚ‹xt
);

49 
DWORD
 
Su¥’dTh»ad
(
HANDLE
 
hTh»ad
);

50 
LPVOID
 
Vœtu®AÎocEx
(
HANDLE
 
hProûss
, LPVOID 
ÍAdd»ss
, 
SIZE_T
 
dwSize
, 
DWORD
 
æAÎoÿtiÚTy³
, DWORD 
æPrÙeù
);

51 
BOOL
 
Vœtu®F»eEx
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍAdd»ss
, 
SIZE_T
 
dwSize
, 
DWORD
 
dwF»eTy³
);

52 
SIZE_T
 
Vœtu®Qu”yEx
(
HANDLE
 
hProûss
, 
LPCVOID
 
ÍAdd»ss
, 
PMEMORY_BASIC_INFORMATION
 
ÍBufãr
, SIZE_T 
dwL’gth
);

53 
BOOL
 
Wr™eProûssMemÜy
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍBa£Add»ss
, 
LPCVOID
 
ÍBufãr
, 
SIZE_T
 
nSize
, SIZE_T* 
ÍNumb”OfBy‹sWr™‹n
);

54 
DWORD
 
G‘FžeSize
(
HANDLE
 
hFže
, 
LPDWORD
 
ÍFžeSizeHigh
);

55 
BOOL
 
Vœtu®PrÙeùEx
(
HANDLE
 
hProûss
, 
LPVOID
 
ÍAdd»ss
, 
SIZE_T
 
dwSize
, 
DWORD
 
æNewPrÙeù
, 
PDWORD
 
ÍæOldPrÙeù
);

56 
BOOL
 
G‘Th»adS–eùÜEÁry
(
HANDLE
 
hTh»ad
, 
DWORD
 
dwS–eùÜ
, 
LPLDT_ENTRY
 
ÍS–eùÜEÁry
);

61 
HMODULE
 
LßdLib¿ryA
(
LPCTSTR
 
ÍFžeName
);

62 
BOOL
 
F»eLib¿ry
(
HMODULE
 
hModuË
);

63 
FARPROC
 
G‘ProcAdd»ss
(
HMODULE
 
hModuË
, 
LPCSTR
 
ÍProcName
);

64 
BOOL
 
FlushIn¡ruùiÚCache
(
HANDLE
 
hProûss
, 
LPCVOID
 
ÍBa£Add»ss
, 
SIZE_T
 
dwSize
);

65 
BOOL
 
ModuË32Fœ¡
(
HANDLE
 
hSÇpshÙ
, 
LPMODULEENTRY32
 
Íme
);

66 
BOOL
 
ModuË32Next
(
HANDLE
 
hSÇpshÙ
, 
LPMODULEENTRY32
 
Íme
);

67 
HANDLE
 
G‘Cu¼’tProûss
();

68 
DWORD
 
G‘La¡E¼Ü
();

69 
DWORD
 
FÜm©Mes§geA
(DWORD 
dwFÏgs
, 
LPCVOID
 
ÍSourû
, DWORD 
dwMes§geId
, DWORD 
dwLªguageId
, 
LPTSTR
 
ÍBufãr
, DWORD 
nSize
, 
va_li¡
* 
Argum’ts
);

70 
HANDLE
 
C»©eFžeM­pšgA
(HANDLE 
hFže
, 
LPSECURITY_ATTRIBUTES
 
ÍA‰ribu‹s
, 
DWORD
 
æPrÙeù
, DWORD 
dwMaximumSizeHigh
, DWORD 
dwMaximumSizeLow
, 
LPCTSTR
 
ÍName
);

71 
LPVOID
 
M­V›wOfFže
(
HANDLE
 
hFžeM­pšgObjeù
, 
DWORD
 
dwDesœedAcûss
, DWORD 
dwFžeOff£tHigh
, DWORD 
dwFžeOff£tLow
, 
SIZE_T
 
dwNumb”OfBy‹sToM­
);

72 
DWORD
 
G‘M­³dFžeName
(
HANDLE
 
hProûss
, 
LPVOID
 
Ív
, 
LPTSTR
 
ÍFž’ame
, DWORD 
nSize
);

73 
BOOL
 
Unm­V›wOfFže
(
LPCVOID
 
ÍBa£Add»ss
);

74 
BOOL
 
O³nProûssTok’
(
HANDLE
 
ProûssHªdË
, 
DWORD
 
DesœedAcûss
, 
PHANDLE
 
Tok’HªdË
);

75 
BOOL
 
LookupPrivžegeV®ueA
(
LPCTSTR
 
ÍSy¡emName
, LPCTSTR 
ÍName
, 
PLUID
 
ÍLuid
);

76 
BOOL
 
Adju¡Tok’Privžeges
(
HANDLE
 
Tok’HªdË
, BOOL 
Di§bËAÎPrivžeges
, 
PTOKEN_PRIVILEGES
 
NewS‹
, 
DWORD
 
BufãrL’gth
, PTOKEN_PRIVILEGES 
P»viousS‹
, 
PDWORD
 
R‘uºL’gth
);

78 
‹¡
(
pid
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\MacX.c

1 
	~<PythÚ.h
>

2 
	~<¡dlib.h
>

3 
	~<¡dio.h
>

4 
	~<mach/mach_Œ­s.h
>

5 
	~<mach/mach_ty³s.h
>

6 
	~<¡ršg.h
>

7 
	~<mach/th»ad_¡©us.h
>

8 
	~<uni¡d.h
>

9 
	~<mach/mach.h
>

10 
	~<sys/ty³s.h
>

11 
	~<sys/sysùl.h
>

12 
	~"im¶em’tiÚ.h
"

14 
mach_pÜt_t
 
	gexû±iÚ_pÜt
;

16 
PyObjeù
 *
	$CÚtšueDebugEv’t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

18 cÚ¡ 
pid
, 
th»ad
, 
¡©us
;

19 
¡s
;

20 
i386_th»ad_¡©e_t
 
¡©e
;

21 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "I", &
th»ad
))

22  
NULL
;

23 
	`g‘_cÚ‹xt
(
th»ad
, &
¡©e
);

24 
¡s
 = 
	`»sume_th»ad
(
th»ad
);

25  
	`Py_BuždV®ue
("i", 
¡s
);

26 
	}
}

28 
PyObjeù
 *
	$DebugAùiveProûss
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

30 cÚ¡ 
pid
;

31 
¡s
;

33 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

34  
NULL
;

35 
¡s
 = 
	`©ch
(
pid
, &
exû±iÚ_pÜt
);

36  
	`Py_BuždV®ue
("i", 
¡s
);

37 
	}
}

39 
PyObjeù
 *
	$Enum”©eProûs£s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

41 
ùl
[4] = {0};

42 
size
 = 0;

43 
kšfo_´oc
 *
kšfo
 = 
NULL
;

44 
i
, 
couÁ
;

46 
ùl
[0] = 
CTL_KERN
;

47 
ùl
[1] = 
KERN_PROC
;

48 
ùl
[2] = 
KERN_PROC_ALL
;

49 
	`sysùl
(
ùl
, 3, 
NULL
, (
size_t
 *è&
size
, NULL, 0);

50 
kšfo
 = 
	`ÿÎoc
(1, 
size
);

51 
	`sysùl
(
ùl
, 3, 
kšfo
, (
size_t
 *è&
size
, 
NULL
, 0);

53 
couÁ
 = 
size
 / (
kšfo_´oc
);

55 
PyObjeù
 *
»t
 = 
	`PyTu¶e_New
(
couÁ
);

56 
i
=0; i < 
couÁ
; i++){

57 
	`PyTu¶e_S‘I‹m
(
»t
, 
i
, 
	`Py_BuždV®ue
("(Is)", 
kšfo
[i].
kp_´oc
.
p_pid
, kšfo[i].kp_´oc.
p_comm
));

59 
	`ä“
(
kšfo
);

61  
»t
;

62 
	}
}

64 
PyObjeù
 *
	$DebugAùiveProûssStÝ
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

66 cÚ¡ 
pid
;

67 
¡s
;

69 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

70  
NULL
;

71 
¡s
 = 
	`d‘ach
(
pid
);

72  
	`Py_BuždV®ue
("i", 
¡s
);

73 
	}
}

76 
PyObjeù
 *
	$Vœtu®F»eEx
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

78 cÚ¡ 
pid
, 
add»ss
, 
size
, 
ty³
;

79 
¡s
;

81 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "iiii", &
pid
, &
add»ss
, &
size
, &
ty³
))

82  
NULL
;

84 
¡s
 = 
	`vœtu®_ä“
(
pid
, 
add»ss
, 
size
);

86  
	`Py_BuždV®ue
("i", 
¡s
);

87 
	}
}

89 
PyObjeù
 *
	$Vœtu®PrÙeùEx
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

91 cÚ¡ 
pid
, 
size
, 
ty³
;

92 *
Þd
;

93 
¡s
;

94 cÚ¡ 
add»ss
;

96 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "iiii", &
pid
, &
add»ss
, &
size
, &
ty³
)){

97 
	`´štf
("Couldn't…arse inputs,„eturning NULL!\n");

98 
	`´štf
("Was it‡ kernel‡ddress?\n");

99  
NULL
;

102 
¡s
 = 
	`vœtu®_´Ùeù
(
pid
, 
add»ss
, 
size
, 
ty³
);

103  
	`Py_BuždV®ue
("i", 
¡s
);

104 
	}
}

107 
PyObjeù
 *
	$Vœtu®AÎocEx
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

109 cÚ¡ 
pid
, 
add»ss
, 
size
, 
ty³
, 
´Ù
;

110 
¡s
;

112 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "iiiii", &
pid
, &
add»ss
, &
size
, &
ty³
, &
´Ù
))

113  
NULL
;

115 
addy
 = (è
	`®loÿ‹
(
pid
, 
add»ss
, 
size
);

117  
	`Py_BuždV®ue
("I", 
addy
);

118 
	}
}

120 
PyObjeù
 *
	$Wa™FÜDebugEv’t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

122 cÚ¡ 
pid
, 
timeout
;

123 
»t
;

124 
ec
, 
id
;

125 
—t
, 
”ef
;

127 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "ii", &
pid
, &
timeout
))

128  
NULL
;

129 
»t
 = 
	`my_msg_£rv”
(
exû±iÚ_pÜt
, 
timeout
, &
id
, &
ec
, &
—t
, &
”ef
);

130  
	`Py_BuždV®ue
("[i,i,i,I,I]", 
»t
, 
id
, 
ec
, 
—t
, 
”ef
);

131 
	}
}

133 
PyObjeù
 *
	$R—dProûssMemÜy
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

135 cÚ¡ 
pid
, 
Ën
;

136 cÚ¡ 
addr
;

137 
¡s
;

138 *
d©a
;

139 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "iIwi", &
pid
, &
addr
, &
d©a
, &
Ën
)){

140 
	`´štf
("Coudn't…arse\n");

141  
NULL
;

143 
¡s
 = 
	`»ad_memÜy
(
pid
, 
addr
, 
Ën
, 
d©a
);

144  
	`Py_BuždV®ue
("i", 
¡s
);

145 
	}
}

147 
PyObjeù
 *
	$Wr™eProûssMemÜy
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

149 cÚ¡ 
pid
, 
Ën
;

150 cÚ¡ 
addr
;

151 **
d©a
;

152 
¡s
;

154 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "iIwi", &
pid
, &
addr
, &
d©a
, &
Ën
)){

155 
	`´štf
("Could‚ot…arse\n");

156  
NULL
;

158 
¡s
 = 
	`wr™e_memÜy
(
pid
, 
addr
, 
Ën
, *
d©a
);

159 
PyObjeù
 *
»t
 = 
	`Py_BuždV®ue
("i", 
¡s
);

160  
»t
;

161 
	}
}

163 
PyObjeù
 *
	$Enum”©eTh»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

165 cÚ¡ 
pid
;

166 
i
;

168 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

169  
NULL
;

171 
th»ad_aù_pÜt_¬¿y_t
 
th»ad_li¡
;

172 
mach_msg_ty³_numb”_t
 
th»ad_couÁ
;

174 
	`g‘_sk_th»ads
(
pid
, &
th»ad_li¡
, &
th»ad_couÁ
);

176 
PyObjeù
 *
»t
 = 
	`PyTu¶e_New
(
th»ad_couÁ
);

177 
i
=0; i < 
th»ad_couÁ
; i++){

178 
	`PyTu¶e_S‘I‹m
(
»t
, 
i
, 
	`Py_BuždV®ue
("I", 
th»ad_li¡
[i]));

180  
»t
;

181 
	}
}

183 
PyObjeù
 *
	$Su¥’dTh»ad
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

185 cÚ¡ 
th»ad
;

186 
i386_th»ad_¡©e_t
 
¡©e
;

187 
¡s
;

189 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "I", &
th»ad
))

190  
NULL
;

191 
¡s
 = 
	`su¥’d_th»ad
(
th»ad
);

192  
	`Py_BuždV®ue
("i", 
¡s
);

193 
	}
}

195 
PyObjeù
 *
	$ResumeTh»ad
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

197 cÚ¡ 
th»ad
;

198 
i386_th»ad_¡©e_t
 
¡©e
;

199 
¡s
, 
i
;

200 
k”n_»tuº_t
 
»t
;

201 
size
 = 
THREAD_BASIC_INFO_COUNT
;

202 
th»ad_basic_šfo
 
šfo
;

204 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "I", &
th»ad
))

205  
NULL
;

207 
¡s
 = 
	`»sume_th»ad
(
th»ad
);

208  
	`Py_BuždV®ue
("i", 
¡s
);

209 
	}
}

211 
PyObjeù
 *
	$T”mš©eProûss
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

213 
pid
, 
ex™code
, 
¡s
;

215 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "ii", &
pid
, &
ex™code
))

216  
NULL
;

217 
¡s
 = 
	`kžl
(
pid
, 9);

218 
¡s
++;

219  
	`Py_BuždV®ue
("i", 
¡s
);

220 
	}
}

222 
	$´štcÚ‹xt
(
i386_th»ad_¡©e_t
 *
¡©e
){

223 
	`´štf
("—x: %x\Ãbx: %x\Ãcx: %x\Ãdx: %x\Ãdi: %x\Ãsi: %x\Ãbp: %x\Ã¥: %x\nss: %x\Ãæags: %x\Ý: %x\ncs: %x\nds: %x\Ãs: %x\nfs: %x\ngs: %x\n", 
¡©e
->
—x
, s‹->
ebx
, s‹->
ecx
, s‹->
edx
, s‹->
edi
, s‹->
esi
, s‹->
ebp
, s‹->
e¥
, s‹->
ss
, s‹->
eæags
, s‹->
e
, s‹->
cs
, s‹->
ds
, s‹->
es
, s‹->
fs
, s‹->
gs
);

224 
	}
}

227 
PyObjeù
 *
	$G‘Th»adCÚ‹xt
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

229 cÚ¡ 
th»ad
;

230 
i386_th»ad_¡©e_t
 
¡©e
;

232 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "I", &
th»ad
))

233  
NULL
;

235 
	`g‘_cÚ‹xt
(
th»ad
, &
¡©e
);

237 
s
}

239 
PyObjeù
 *
	$S‘Th»adCÚ‹xt
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

241 cÚ¡ 
th»ad
;

242 
i386_th»ad_¡©e_t
 
¡©e
;

243 
¡s
;

244 
x
;

247 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "i(IIIIIIIIIIIIIIII)", &
th»ad
, &
¡©e
.
—x
, &¡©e.
ebx
, &¡©e.
ecx
, &¡©e.
edx
, &¡©e.
edi
, &¡©e.
esi
, &¡©e.
ebp
, &¡©e.
e¥
, &¡©e.
ss
, &¡©e.
eæags
, &¡©e.
e
, &¡©e.
cs
, &¡©e.
ds
, &¡©e.
es
, &¡©e.
fs
, &¡©e.
gs
))

248  
NULL
;

249 
¡s
 = 
	`£t_cÚ‹xt
(
th»ad
, &
¡©e
);

250  
	`Py_BuždV®ue
("i", 
¡s
);

251 
	}
}

253 
PyObjeù
 *
	$Vœtu®Qu”yEx
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
){

254 cÚ¡ 
pid
;

255 
addr
;

256 
´Ù
;

257 
size
;

258 
¡s
;

259 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "iI", &
pid
, &
addr
)){

260 
	`´štf
("Couldn't…arse‡rguments in VirtualQuery\nWas it‡ kernel‡ddress?");

261  
NULL
;

263 
	`vœtu®_qu”y
(
pid
, &
addr
, &
´Ù
, &
size
);

265 
PyObjeù
 *
»t
 = 
	`Py_BuždV®ue
("[I,I]", 
addr
, 
´Ù
);

266  
»t
;

267 
	}
}

269 
PyM‘hodDef
 
	gMacXM‘hods
[] = {

270 {"CÚtšueDebugEv’t", 
CÚtšueDebugEv’t
, 
METH_VARARGS
, "Continue debugƒvent"},

271 {"DebugAùiveProûss", 
DebugAùiveProûss
, 
METH_VARARGS
, "Attacho‡…rocess"},

272 {"Enum”©eTh»ads", 
Enum”©eTh»ads
, 
METH_VARARGS
, "Get†isting ofhreads"},

273 {"Enum”©eProûs£s", 
Enum”©eProûs£s
, 
METH_VARARGS
, "Get…rocess†isting"},

274 {"DebugAùiveProûssStÝ", 
DebugAùiveProûssStÝ
, 
METH_VARARGS
, "Detach from‡…rocess"},

275 {"Wa™FÜDebugEv’t", 
Wa™FÜDebugEv’t
, 
METH_VARARGS
, "Continue‡n‡ttached…rocess"},

276 {"Su¥’dTh»ad", 
Su¥’dTh»ad
, 
METH_VARARGS
, "Suspendhread"},

277 {"ResumeTh»ad", 
ResumeTh»ad
, 
METH_VARARGS
, "Resumehread"},

278 {"T”mš©eProûss", 
T”mš©eProûss
, 
METH_VARARGS
, "Terminate‡…rocess"},

279 {"R—dProûssMemÜy", 
R—dProûssMemÜy
, 
METH_VARARGS
, "Read 4 bytes from memory of‡ttached…rocess"},

280 {"Wr™eProûssMemÜy", 
Wr™eProûssMemÜy
, 
METH_VARARGS
, "Write 4 bytes into‡ttached…rocess's memory"},

281 {"G‘Th»adCÚ‹xt", 
G‘Th»adCÚ‹xt
, 
METH_VARARGS
, "Get context for‡hread"},

282 {"S‘Th»adCÚ‹xt", 
S‘Th»adCÚ‹xt
, 
METH_VARARGS
, "Set context for‡hread"},

283 {"Vœtu®Qu”yEx", 
Vœtu®Qu”yEx
, 
METH_VARARGS
, "Get memory„egion information"},

284 {"Vœtu®AÎocEx", 
Vœtu®AÎocEx
, 
METH_VARARGS
, "Allocate memory"},

285 {"Vœtu®F»eEx", 
Vœtu®F»eEx
, 
METH_VARARGS
, "Free memory"},

286 {"Vœtu®PrÙeùEx", 
Vœtu®PrÙeùEx
, 
METH_VARARGS
, "VirtualProtect"},

287 {
NULL
, NULL, 0, NULL}

290 
PyMODINIT_FUNC
 
	$š™MacX
(){

291 (è
	`Py_In™ModuË
("MacX", 
MacXM‘hods
);

292 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\dyld.c

10 
	~<mach-o/ldsyms.h
>

11 
	~"MacDÎ.h
"

12 
	~"dyld.h
"

13 
	~"im¶em’tiÚ.h
"

15 
EXPORT


16 
	$macosx_loÿ‹_dyld
(
pid
, *
addr
){

17 
k”n_»tuº_t
 
k»t
 = 
KERN_SUCCESS
;

18 
vm_»giÚ_basic_šfo
 
šfo
;

19 
mach_msg_ty³_numb”_t
 
šfo_út
 = 
VM_REGION_BASIC_INFO_COUNT
;

20 
mach_vm_add»ss_t
 
‹¡_addr
 = 
VM_MIN_ADDRESS
;

21 
mach_vm_size_t
 
size
 = 0;

22 
mach_pÜt_t
 
objeù_Çme
 = 
MACH_PORT_NULL
;

24 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

27 
k»t
 = 
	`vm_»giÚ
 (
pÜt
, (*è&
‹¡_addr
, (*è&
size
, 
VM_REGION_BASIC_INFO
, (
vm_»giÚ_šfo_t
è&
šfo
, &
šfo_út
, &
objeù_Çme
);

29 ià(
k»t
 !ð
KERN_SUCCESS
)

32 ià(
	`dyld_¡¬ts_h”e_p
 (
pÜt
, 
‹¡_addr
)){

33 *
addr
 = 
‹¡_addr
;

37 
‹¡_addr
 +ð
size
;

39 } 
size
 != 0);

41 
	}
}

43 
	$dyld_¡¬ts_h”e_p
 (
sk_t
 
pÜt
, 
mach_vm_add»ss_t
 
addr
)

45 
mach_vm_add»ss_t
 
add»ss
 = 
addr
;

46 
mach_vm_size_t
 
size
 = 0;

47 
vm_»giÚ_basic_šfo
 
šfo
;

48 
mach_msg_ty³_numb”_t
 
šfo_út
 = 
VM_REGION_BASIC_INFO_COUNT
;

49 
k”n_»tuº_t
 
»t
;

50 
mach_pÜt_t
 
objeù_Çme
;

51 
vm_add»ss_t
 
d©a
;

52 
vm_size_t
 
d©a_couÁ
;

54 
mach_h—d”
 *
mh
;

56 
»t
 = 
	`vm_»giÚ
 (
pÜt
, (*è&
add»ss
, (*è&
size
, 
VM_REGION_BASIC_INFO
, (
vm_»giÚ_šfo_t
è& 
šfo
, &
šfo_út
, &
objeù_Çme
);

58 ià(
»t
 !ð
KERN_SUCCESS
)

63 ià((
šfo
.
´ÙeùiÚ
 & 
VM_PROT_READ
) == 0)

66 
»t
 = 
	`vm_»ad
 (
pÜt
, 
add»ss
, 
size
, &
d©a
, &
d©a_couÁ
);

68 ià(
»t
 !ð
KERN_SUCCESS
){

77 ià(
d©a_couÁ
 <  (
mach_h—d”
)){

78 
»t
 = 
	`vm_d—Îoÿ‹
 (
	`mach_sk_£lf
 (), 
d©a
, 
d©a_couÁ
);

82 
mh
 = (
mach_h—d”
 *è
d©a
;

87 ià((
mh
->
magic
 !ð
MH_MAGIC
 && mh->magiø!ð
MH_CIGAM
 &&

88 
mh
->
magic
 !ð
MH_MAGIC_64
 && mh->magiø!ð
MH_CIGAM_64
) ||

89 
mh
->
fž‘y³
 !ð
MH_DYLINKER
 ||

90 
d©a_couÁ
 <  (
mach_h—d”
è+ 
mh
->
sizeofcmds
)

92 
»t
 = 
	`vm_d—Îoÿ‹
 (
	`mach_sk_£lf
 (), 
d©a
, 
d©a_couÁ
);

97 
»t
 = 
	`vm_d—Îoÿ‹
 (
	`mach_sk_£lf
 (), 
d©a
, 
d©a_couÁ
);

100 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\dyld.h

9 

	#EXPORT
 
	`__©Œibu‹__
((
	`visibž™y
("deçuÉ")))

	)

12 
dyld_¡¬ts_h”e_p
 (
sk_t
 
pÜt
, 
mach_vm_add»ss_t
 
addr
);

13 
macosx_loÿ‹_dyld
(
pid
, *
addr
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\implementation.c

1 
	~<¡dlib.h
>

2 
	~<sys/ty³s.h
>

3 
	~<sys/±¿û.h
>

4 
	~<¡dio.h
>

5 
	~<mach/mach.h
>

6 
	~<mach/mach_Œ­s.h
>

7 
	~<mach/mach_ty³s.h
>

8 
	~<¡ršg.h
>

9 
	~<mach/th»ad_¡©us.h
>

10 
	~<uni¡d.h
>

11 
	~<sigÇl.h
>

12 
	~<£tjmp.h
>

13 
	~<im¶em’tiÚ.h
>

14 
	~"Exû±iÚ.h
"

16 

	#EXPORT
 
	`__©Œibu‹__
((
	`visibž™y
("deçuÉ")))

	)

25 
sk_t
 
	gour_pÜt
 = -1;

27 
sk_t
 
	$g‘pÜt
(
pid
){

28 if(
our_pÜt
 == -1){

29 
sk_t
 
pÜt
;

30 if(
	`sk_fÜ_pid
(
	`mach_sk_£lf
(), 
pid
, &
pÜt
)){

34 
our_pÜt
 = 
pÜt
;

36  
our_pÜt
;

37 
	}
}

39 
	$©ch
(
pid
, 
mach_pÜt_t
 *
•
){

41 
our_pÜt
 = -1;

42 
	`g‘pÜt
(
pid
);

44 *
•
 = 
	`š™
(
pid
);

51 
	}
}

53 
	$d‘ach
(
pid
, 
mach_pÜt_t
 *
•
){

55 
mach_pÜt_t
 
me
;

56 
me
 = 
	`mach_sk_£lf
();

73 
k”n_»tuº_t
 
”r
 = 
	`mach_pÜt_d—Îoÿ‹
(
me
, *
•
);

74 if(
”r
!ð
KERN_SUCCESS
){

76 ià(
”r
==
KERN_INVALID_TASK
){

78 } ià(
”r
==
KERN_INVALID_NAME
) {

80 } ià(
”r
==
KERN_INVALID_RIGHT
) {

91 
	}
}

93 
	$g‘_sk_th»ads
(
pid
, 
th»ad_aù_pÜt_¬¿y_t
 *
th»ad_li¡
, 
mach_msg_ty³_numb”_t
 *
th»ad_couÁ
){

95 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

96 
	`sk_th»ads
(
pÜt
, 
th»ad_li¡
, 
th»ad_couÁ
);

98 
	}
}

100 
	$vœtu®_ä“
(
pid
, 
add»ss
, 
size
){

101 
¡s
;

102 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

104 
k”n_»tuº_t
 
”r
 = 
	`vm_d—Îoÿ‹
(
pÜt
, 
add»ss
, 
size
);

105 if(
”r
!ð
KERN_SUCCESS
){

106 
¡s
 = 0;

108 
¡s
 = 1;

110  
¡s
;

111 
	}
}

113 
vm_´Ù_t
 
	$wšToXPrÙeùiÚ
(
ty³
){

114 
vm_´Ù_t
 
mac_´Ù
 = 0;

115 
ty³
){

116 
PAGE_NOACCESS
:

118 
PAGE_READONLY
:

119 
mac_´Ù
 = 
VM_PROT_READ
;

121 
PAGE_READWRITE
:

122 
mac_´Ù
 = 
VM_PROT_READ
 | 
VM_PROT_WRITE
;

124 
PAGE_EXECUTE
:

125 
mac_´Ù
 = 
VM_PROT_EXECUTE
;

127 
PAGE_EXECUTE_READ
:

128 
mac_´Ù
 = 
VM_PROT_EXECUTE
 | 
VM_PROT_READ
;

130 
PAGE_EXECUTE_READWRITE
:

131 
mac_´Ù
 = 
VM_PROT_EXECUTE
 | 
VM_PROT_READ
 | 
VM_PROT_WRITE
;

133 
PAGE_GUARD
:

134 
PAGE_NOCACHE
:

135 
PAGE_WRITECOMBINE
:

139  
mac_´Ù
;

140 
	}
}

142 
	$XToWšPrÙeùiÚ
(
vm_´Ù_t
 
mac
){

143 
»t
;

144 
mac
){

145 
VM_PROT_READ
:

146 
»t
 = 
PAGE_READONLY
;

148 
VM_PROT_READ
 | 
VM_PROT_WRITE
:

149 
»t
 = 
PAGE_READWRITE
;

151 
VM_PROT_EXECUTE
:

152 
»t
 = 
PAGE_EXECUTE
;

154 
VM_PROT_EXECUTE
 | 
VM_PROT_READ
:

155 
»t
 = 
PAGE_EXECUTE_READ
;

157 
VM_PROT_EXECUTE
 | 
VM_PROT_READ
 | 
VM_PROT_WRITE
:

158 
»t
 = 
PAGE_EXECUTE_READWRITE
;

161 
»t
 = 
PAGE_NOACCESS
;

163  
»t
;

164 
	}
}

166 
	$vœtu®_´Ùeù
(
pid
, 
add»ss
, 
size
, 
ty³
){

167 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

169 
¡s
;

170 
vm_´Ù_t
 
mac_´Ù
 = 
	`wšToXPrÙeùiÚ
(
ty³
);

173 
k”n_»tuº_t
 
”r
 = 
	`vm_´Ùeù
(
pÜt
, 
add»ss
, 
size
, 
FALSE
, 
mac_´Ù
);

174 if(
”r
 =ð
KERN_SUCCESS
){

175 
¡s
 = 1;

176 } if(
”r
 =ð
KERN_PROTECTION_FAILURE
){

177 
¡s
 = 1;

181 
¡s
 = 1;

183  
¡s
;

184 
	}
}

186 *
	$®loÿ‹
(
pid
, 
add»ss
, 
size
){

187 *
d©a
;

189 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

190 
k”n_»tuº_t
 
”r
 = 
	`vm_®loÿ‹
(
pÜt
, (
vm_add»ss_t
*è&
d©a
, 
size
, 
VM_FLAGS_ANYWHERE
);

191 if(
”r
!ð
KERN_SUCCESS
){

192 
d©a
 = 
NULL
;

195  
d©a
;

196 
	}
}

198 
	$»ad_memÜy
(
pid
, 
addr
, 
Ën
, *
d©a
){

200 
mach_msg_ty³_numb”_t
 
Ä—d
;

201 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

202 
	`vm_»ad_ov”wr™e
(
pÜt
, 
addr
, 
Ën
, (è
d©a
, &
Ä—d
);

203 if(
Ä—d
 !ð
Ën
){

208 
	}
}

210 
	$wr™e_memÜy
(
pid
, 
addr
, 
Ën
, *
d©a
){

212 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

213 
k”n_»tuº_t
 
»t
 = 
	`vm_wr™e
(
pÜt
, 
addr
, (
poš‹r_t
è
d©a
, 
Ën
);

214 if(
»t
){

216 if(
»t
 =ð
KERN_PROTECTION_FAILURE
)

218 if(
»t
 =ð
KERN_INVALID_ADDRESS
)

223 
	}
}

225 
	$g‘_cÚ‹xt
(
th»ad_aù_t
 
th»ad
, 
i386_th»ad_¡©e_t
 *
¡©e
){

227 
mach_msg_ty³_numb”_t
 
sc
 = 
i386_THREAD_STATE_COUNT
;

228 
	`th»ad_g‘_¡©e
Ð
th»ad
, 
i386_THREAD_STATE
, (
th»ad_¡©e_t
è
¡©e
, &
sc
);

230 
	}
}

232 
	$su¥’d_th»ad
(
th»ad
){

233 
¡s
;

235 
¡s
 = 
	`th»ad_su¥’d
(
th»ad
);

236 if(
¡s
 =ð
KERN_SUCCESS
){

237 
¡s
 = 0;

240 
¡s
 = -1;

242  
¡s
;

243 
	}
}

245 
	$»sume_th»ad
(
th»ad
){

246 
i
;

247 
k”n_»tuº_t
 
»t
;

249 
size
 = 
THREAD_BASIC_INFO_COUNT
;

250 
th»ad_basic_šfo
 
šfo
;

252 
»t
 = 
	`th»ad_šfo
(
th»ad
, 
THREAD_BASIC_INFO
, (
th»ad_šfo_t
è&
šfo
, &
size
);

253 if(
»t
 !ð
KERN_SUCCESS
){

258 
i
 = 0; i < 
šfo
.
su¥’d_couÁ
; i++){

259 
»t
 = 
	`th»ad_»sume
(
th»ad
);

260 if(
»t
 !ð
KERN_SUCCESS
){

266 
	}
}

268 
	$vœtu®_qu”y
(
pid
, *
ba£addr
, *
´Ù
, *
size
){

269 
sk_t
 
pÜt
 = 
	`g‘pÜt
(
pid
);

271 
mach_msg_ty³_numb”_t
 
couÁ
 = 
VM_REGION_BASIC_INFO_COUNT
;

272 
vm_»giÚ_basic_šfo
 
šfo
;

273 
mach_pÜt_t
 
objeùName
 = 
MACH_PORT_NULL
;

274 
»que¡ed_ba£
 = *
ba£addr
;

275 
k”n_»tuº_t
 
»suÉ
 = 
	`vm_»giÚ
(
pÜt
, 
ba£addr
, 
size
, 
VM_REGION_BASIC_INFO
, (
vm_»giÚ_šfo_t
è&
šfo
, &
couÁ
, &
objeùName
);

280 if(
»suÉ
 !ð
KERN_SUCCESS
){

282 *
size
 = 0xfffffffà- 
»que¡ed_ba£
 + 1;

283 *
´Ù
 = 
PAGE_NOACCESS
;

288 if(*
ba£addr
 > 
»que¡ed_ba£
){

290 *
size
 = *
ba£addr
 - 
»que¡ed_ba£
;

291 *
ba£addr
 = 
»que¡ed_ba£
;

292 *
´Ù
 = 
PAGE_NOACCESS
;

297 *
´Ù
 = 
	`XToWšPrÙeùiÚ
(
šfo
.
´ÙeùiÚ
);

300 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\implementation.h

10 

	#MEM_COMMIT
 0x00001000

	)

11 

	#MEM_DECOMMIT
 0x00004000

	)

12 

	#MEM_IMAGE
 0x01000000

	)

13 

	#MEM_RELEASE
 0x00008000

	)

15 

	#PAGE_NOACCESS
 0x00000001

	)

16 

	#PAGE_READONLY
 0x00000002

	)

17 

	#PAGE_READWRITE
 0x00000004

	)

18 

	#PAGE_WRITECOPY
 0x00000008

	)

19 

	#PAGE_EXECUTE
 0x00000010

	)

20 

	#PAGE_EXECUTE_READ
 0x00000020

	)

21 

	#PAGE_EXECUTE_READWRITE
 0x00000040

	)

22 

	#PAGE_EXECUTE_WRITECOPY
 0x00000080

	)

23 

	#PAGE_GUARD
 0x00000100

	)

24 

	#PAGE_NOCACHE
 0x00000200

	)

25 

	#PAGE_WRITECOMBINE
 0x00000400

	)

27 
©ch
(
pid
, 
mach_pÜt_t
 *
•
);

28 
d‘ach
(
pid
, 
mach_pÜt_t
 *
•
);

29 
g‘_sk_th»ads
(
pid
, 
th»ad_aù_pÜt_¬¿y_t
 *
th»ad_li¡
, 
mach_msg_ty³_numb”_t
 *
th»ad_couÁ
);

30 
vœtu®_ä“
(
pid
, 
add»ss
, 
size
);

31 
vœtu®_´Ùeù
(
pid
, 
add»ss
, 
size
, 
ty³
);

32 *
®loÿ‹
(
pid
, 
add»ss
, 
size
);

33 
»ad_memÜy
(
pid
, 
addr
, 
Ën
, *
d©a
);

34 
wr™e_memÜy
(
pid
, 
addr
, 
Ën
, *
d©a
);

35 
g‘_cÚ‹xt
(
th»ad_aù_t
 
th»ad
, 
i386_th»ad_¡©e_t
 *
¡©e
);

36 
su¥’d_th»ad
(
th»ad
);

37 
»sume_th»ad
(
th»ad
);

38 
£t_cÚ‹xt
(
th»ad_aù_t
 
th»ad
, 
i386_th»ad_¡©e_t
 *
¡©e
);

39 
vœtu®_qu”y
(
pid
, *
ba£addr
, *
´Ù
, *
size
);

40 
®loÿ‹_š_th»ad
(
th»adId
, 
size
);

41 
sk_t
 
g‘pÜt
(
pid
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\main.c

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\windows.h

1 

	#BOOL
 

	)

2 

	#WORD
 

	)

3 

	#DWORD
 

	)

4 

	#LPVOID
 *

	)

5 

	#LPDWORD
 *

	)

6 

	#PDWORD
 *

	)

7 

	#DWORD_PTR
 *

	)

8 

	#LPSYSTEM_INFO
 
SYSTEM_INFO
 *

	)

9 

	#HMODULE
 

	)

10 

	#LPCSTR
 *

	)

11 

	#LPCTSTR
 *

	)

12 

	#HANDLE
 

	)

13 

	#FARPROC
 

	)

14 

	#PVOID
 

	)

15 

	#ULONG_PTR
 *

	)

16 

	#LPCVOID
 *

	)

17 

	#SIZE_T
 
size_t


	)

18 

	#UINT
 

	)

19 

	#BYTE
 

	)

20 

	#TCHAR
 

	)

21 

	#LPMODULEENTRY32
 
MODULEENTRY32
 *

	)

22 

	#LPPROCESSENTRY32
 
PROCESSENTRY32
 *

	)

23 

	#LONG
 

	)

24 

	#LPTHREADENTRY32
 
THREADENTRY32
 *

	)

25 

	#LPCONTEXT
 
CONTEXT
 *

	)

26 

	#LPTSTR
 *

	)

27 

	#LPSECURITY_ATTRIBUTES
 *

	)

28 

	#LPBYTE
 *

	)

29 

	#PHANDLE
 

	)

31 

	#MAX_PATH
 260

	)

32 

	#EXCEPTION_MAXIMUM_PARAMETERS
 15

	)

33 

	#MAX_MODULE_NAME32
 255

	)

34 

	#ANYSIZE_ARRAY
 1

	)

36 

	#EXCEPTION_DEBUG_EVENT
 1

	)

39 
	s_SYSTEM_INFO
 {

41 
DWORD
 
	mdwOemId
;

43 
WORD
 
	mwProûssÜArch™eùu»
;

44 
WORD
 
	mwRe£rved
;

47 
DWORD
 
	mdwPageSize
;

48 
LPVOID
 
	mÍMšimumAµliÿtiÚAdd»ss
;

49 
LPVOID
 
	mÍMaximumAµliÿtiÚAdd»ss
;

50 
DWORD_PTR
 
	mdwAùiveProûssÜMask
;

51 
DWORD
 
	mdwNumb”OfProûssÜs
;

52 
DWORD
 
	mdwProûssÜTy³
;

53 
DWORD
 
	mdwAÎoÿtiÚG¿nuÏr™y
;

54 
WORD
 
	mwProûssÜLev–
;

55 
WORD
 
	mwProûssÜRevisiÚ
;

56 } 
	tSYSTEM_INFO
;

58 
	s_EXCEPTION_RECORD
 {

59 
DWORD
 
	mExû±iÚCode
;

60 
DWORD
 
	mExû±iÚFÏgs
;

61 
_EXCEPTION_RECORD
* 
	mExû±iÚRecÜd
;

62 
PVOID
 
	mExû±iÚAdd»ss
;

63 
DWORD
 
	mNumb”P¬am‘”s
;

64 
ULONG_PTR
 
	mExû±iÚInfÜm©iÚ
[
EXCEPTION_MAXIMUM_PARAMETERS
];

65 } 
	tEXCEPTION_RECORD
,

66 *
	tPEXCEPTION_RECORD
;

68 
	s_EXCEPTION_DEBUG_INFO
 {

69 
EXCEPTION_RECORD
 
	mExû±iÚRecÜd
;

70 
DWORD
 
	mdwFœ¡Chªû
;

71 } 
	tEXCEPTION_DEBUG_INFO
,

72 *
	tLPEXCEPTION_DEBUG_INFO
;

74 
	s_DEBUG_EVENT
 {

75 
DWORD
 
	mdwDebugEv’tCode
;

76 
DWORD
 
	mdwProûssId
;

77 
DWORD
 
	mdwTh»adId
;

80 
EXCEPTION_DEBUG_INFO
 
	mExû±iÚ
;

81 } 
	mu
;

82 } 
	tDEBUG_EVENT
,

83 *
	tLPDEBUG_EVENT
;

85 
	sgMODULEENTRY32
 {

86 
DWORD
 
	mdwSize
;

87 
DWORD
 
	mth32ModuËID
;

88 
DWORD
 
	mth32ProûssID
;

89 
DWORD
 
	mGlblútU§ge
;

90 
DWORD
 
	mProcútU§ge
;

91 
BYTE
* 
	mmodBa£Addr
;

92 
DWORD
 
	mmodBa£Size
;

93 
HMODULE
 
	mhModuË
;

94 
TCHAR
 
	mszModuË
[
MAX_MODULE_NAME32
 + 1];

95 
TCHAR
 
	mszExeP©h
[
MAX_PATH
];

96 } 
	tMODULEENTRY32
,

97 *
	tPMODULEENTRY32
;

99 
	sgPROCESSENTRY32
 {

100 
DWORD
 
	mdwSize
;

101 
DWORD
 
	mútU§ge
;

102 
DWORD
 
	mth32ProûssID
;

103 
ULONG_PTR
 
	mth32DeçuÉH—pID
;

104 
DWORD
 
	mth32ModuËID
;

105 
DWORD
 
	mútTh»ads
;

106 
DWORD
 
	mth32P¬’tProûssID
;

107 
LONG
 
	mpcPriCÏssBa£
;

108 
DWORD
 
	mdwFÏgs
;

109 
TCHAR
 
	mszExeFže
[
MAX_PATH
];

110 } 
	tPROCESSENTRY32
,

111 *
	tPPROCESSENTRY32
;

113 
	sgTHREADENTRY32
 {

114 
DWORD
 
	mdwSize
;

115 
DWORD
 
	mútU§ge
;

116 
DWORD
 
	mth32Th»adID
;

117 
DWORD
 
	mth32OwÃrProûssID
;

118 
LONG
 
	mBa£Pri
;

119 
LONG
 
	mD–Pri
;

120 
DWORD
 
	mdwFÏgs
;

121 } 
	tTHREADENTRY32
,

122 *
	tPTHREADENTRY32
;

124 

	#MAXIMUM_SUPPORTED_EXTENSION
 512

	)

125 

	#SIZE_OF_80387_REGISTERS
 80

	)

127 
	s_FLOATING_SAVE_AREA
 {

128 
DWORD
 
	mCÚŒÞWÜd
;

129 
DWORD
 
	mStusWÜd
;

130 
DWORD
 
	mTagWÜd
;

131 
DWORD
 
	mE¼ÜOff£t
;

132 
DWORD
 
	mE¼ÜS–eùÜ
;

133 
DWORD
 
	mD©aOff£t
;

134 
DWORD
 
	mD©aS–eùÜ
;

135 
BYTE
 
	mRegi¡”A»a
[
SIZE_OF_80387_REGISTERS
];

136 
DWORD
 
	mCr0NpxS‹
;

137 } 
	tFLOATING_SAVE_AREA
;

139 
	s_CONTEXT
 {

140 
DWORD
 
	mCÚ‹xtFÏgs
;

141 
DWORD
 
	mDr0
;

142 
DWORD
 
	mDr1
;

143 
DWORD
 
	mDr2
;

144 
DWORD
 
	mDr3
;

145 
DWORD
 
	mDr6
;

146 
DWORD
 
	mDr7
;

147 
FLOATING_SAVE_AREA
 
	mFlßtSave
;

148 
DWORD
 
	mSegGs
;

149 
DWORD
 
	mSegFs
;

150 
DWORD
 
	mSegEs
;

151 
DWORD
 
	mSegDs
;

152 
DWORD
 
	mEdi
;

153 
DWORD
 
	mEsi
;

154 
DWORD
 
	mEbx
;

155 
DWORD
 
	mEdx
;

156 
DWORD
 
	mEcx
;

157 
DWORD
 
	mEax
;

158 
DWORD
 
	mEbp
;

159 
DWORD
 
	mE
;

160 
DWORD
 
	mSegCs
;

161 
DWORD
 
	mEFÏgs
;

162 
DWORD
 
	mE¥
;

163 
DWORD
 
	mSegSs
;

164 
BYTE
 
	mEx‹ndedRegi¡”s
[
MAXIMUM_SUPPORTED_EXTENSION
];

165 } 
	tCONTEXT
;

168 
	s_STARTUPINFO
 {

169 
DWORD
 
	mcb
;

170 
LPTSTR
 
	mÍRe£rved
;

171 
LPTSTR
 
	mÍDesktÝ
;

172 
LPTSTR
 
	mÍT™Ë
;

173 
DWORD
 
	mdwX
;

174 
DWORD
 
	mdwY
;

175 
DWORD
 
	mdwXSize
;

176 
DWORD
 
	mdwYSize
;

177 
DWORD
 
	mdwXCouÁCh¬s
;

178 
DWORD
 
	mdwYCouÁCh¬s
;

179 
DWORD
 
	mdwFžlA‰ribu‹
;

180 
DWORD
 
	mdwFÏgs
;

181 
WORD
 
	mwShowWšdow
;

182 
WORD
 
	mcbRe£rved2
;

183 
LPBYTE
 
	mÍRe£rved2
;

184 
HANDLE
 
	mhStdIÅut
;

185 
HANDLE
 
	mhStdOuut
;

186 
HANDLE
 
	mhStdE¼Ü
;

187 } 
	tSTARTUPINFO
,

188 *
	tLPSTARTUPINFO
;

190 
	s_PROCESS_INFORMATION
 {

191 
HANDLE
 
	mhProûss
;

192 
HANDLE
 
	mhTh»ad
;

193 
DWORD
 
	mdwProûssId
;

194 
DWORD
 
	mdwTh»adId
;

195 } 
	tPROCESS_INFORMATION
,

196 *
	tLPPROCESS_INFORMATION
;

198 
	s_MEMORY_BASIC_INFORMATION
 {

199 
PVOID
 
	mBa£Add»ss
;

200 
PVOID
 
	mAÎoÿtiÚBa£
;

201 
DWORD
 
	mAÎoÿtiÚPrÙeù
;

202 
SIZE_T
 
	mRegiÚSize
;

203 
DWORD
 
	mS‹
;

204 
DWORD
 
	mPrÙeù
;

205 
DWORD
 
	mTy³
;

206 } 
	tMEMORY_BASIC_INFORMATION
,

207 *
	tPMEMORY_BASIC_INFORMATION
;

209 
	s_LUID
 {

210 
DWORD
 
	mLowP¬t
;

211 
LONG
 
	mHighP¬t
;

212 } 
	tLUID
,

213 *
	tPLUID
;

215 
	s_LUID_AND_ATTRIBUTES
 {

216 
LUID
 
	mLuid
;

217 
DWORD
 
	mA‰ribu‹s
;

218 } 
	tLUID_AND_ATTRIBUTES
,

219 *
	tPLUID_AND_ATTRIBUTES
;

221 
	s_TOKEN_PRIVILEGES
 {

222 
DWORD
 
	mPrivžegeCouÁ
;

223 
LUID_AND_ATTRIBUTES
 
	mPrivžeges
[
ANYSIZE_ARRAY
];

224 } 
	tTOKEN_PRIVILEGES
,

225 *
	tPTOKEN_PRIVILEGES
;

227 
	s_TÚe
{

228 
BYTE
 
	mBa£Mid
;

229 
BYTE
 
	mFÏgs1
;

230 
BYTE
 
	mFÏgs2
;

231 
BYTE
 
	mBa£Hi
;

232 } 
	tTÚe
;

234 
	s_Ttwo
{

235 
DWORD
 
	mBa£Mid
;

236 
DWORD
 
	mTy³
;

237 
DWORD
 
	mD¶
;

238 
DWORD
 
	mP»s
;

239 
DWORD
 
	mLim™Hi
;

240 
DWORD
 
	mSys
;

241 
DWORD
 
	mRe£rved_0
;

242 
DWORD
 
	mDeçuÉ_big
;

243 
DWORD
 
	mG¿nuÏr™y
;

244 
DWORD
 
	mBa£Hi
;

245 } 
	tTtwo
;

247 
	s_BLAH
{

248 
TÚe
 
	mBy‹s
;

249 
Ttwo
 
	mB™s
;

250 } 
	tBLAH
;

252 
	s_LDT_ENTRY
 {

253 
WORD
 
	mLimm™Low
;

254 
WORD
 
	mBa£Low
;

255 
BLAH
 
	mHighWÜd
;

256 } 
	tLDT_ENTRY
,

257 *
	tLPLDT_ENTRY
;

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\olly_callbacks.h

24 
BOOL
 
WINAPI
 
	$DÎEÁryPošt
 (
HINSTANCE
 
hi
, 
DWORD
 
»asÚ
, 
LPVOID
 
ȣrved
)

26 ià(
»asÚ
 =ð
DLL_PROCESS_ATTACH
)

27 
hš¡
 = 
hi
;

29  
TRUE
;

30 
	}
}

33 
_expÜt
 
cdeþ
 
	$ODBG_Plugšd©a
 (
shÜŠame
[32])

35 
	`¡rýy
(
shÜŠame
, "PaiMei Connector");

36  
PLUGIN_VERSION
;

37 
	}
}

40 
_expÜt
 
cdeþ
 
	$ODBG_Plugšš™
 (
Þlydbgv”siÚ
, 
HWND
 
hw
, 
ulÚg
 *
ã©u»s
)

42 ià(
Þlydbgv”siÚ
 < 
PLUGIN_VERSION
)

46 
hwmaš
 = 
hw
;

48 
	`Þly_add_to_li¡
(0, 0, "PaiMe˜CÚÃùÜ Plug-š compžed oÀ" 
__DATE__
);

49 
	`Þly_add_to_li¡
(0, -1, " Copyright (c) 2006 Pedram Amini <pedram.amini@gmail.com>");

52 
	}
}

55 
_expÜt
 
cdeþ
 
	$ODBG_Plugšde¡roy
 ()

57 
	}
}

60 
_expÜt
 
cdeþ
 
	$ODBG_Plugšm’u
 (
Üigš
, 
d©a
[4096], *
™em
)

62 
Üigš
)

64 
PM_MAIN
:

65 
	`¡rýy
(
d©a
,

72 
PM_DISASM
:

73 
PM_CPUDUMP
:

74 
	`¡rýy
(
d©a
,

85 
	}
}

88 
_expÜt
 
cdeþ
 
	$ODBG_PlugšaùiÚ
 (
Üigš
, 
aùiÚ
, *
™em
)

90 
t_dump
 *
pd
;

91 
pd
 = (
t_dump
 *è
™em
;

93 
Üigš
)

95 
PM_MAIN
:

96 
PM_DISASM
:

97 
PM_CPUDUMP
:

98 
aùiÚ
)

102 
	`·imei_cÚÃù
();

107 
	`·imei_xm™_loÿtiÚ
(
pd
);

112 
	`þo£sock‘
(
cÚÃùiÚ
);

113 
	`WSAC˪up
();

114 
cÚÃùiÚ
 = 
NULL
;

119 
	`Mes§geBox
(
hwmaš
,

123 
MB_OK
 | 
MB_ICONINFORMATION
);

130 
	}
}

133 
_expÜt
 
cdeþ
 
	$ODBG_PlugšshÜtcut
(
Üigš
, 
ù¾
, 
®t
, 
shiá
, 
key
, *
™em
)

135 
t_dump
 *
pd
;

137 
pd
 = (
t_dump
 *è
™em
;

139 
Üigš
)

141 
PM_DISASM
:

143 ià(
key
 == 188 || key == 190 || key == 191)

145 ià(!
cÚÃùiÚ
)

146 
	`·imei_cÚÃù
();

149 ià(
key
 == 188)

150 
	`S’dshÜtcut
(
PM_MAIN
, 0, 
WM_KEYDOWN
, 0, 0, 
VK_F7
);

153 ià(
key
 == 190)

154 
	`S’dshÜtcut
(
PM_MAIN
, 0, 
WM_KEYDOWN
, 0, 0, 
VK_F8
);

157 
	`·imei_xm™_loÿtiÚ
(
pd
);

164 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\olly_redefines.h

22 #iâdeà
__OLLY_REDEFINES_H__


23 

	#__OLLY_REDEFINES_H__


	)

25 

	#Þly_add_sÜ‹d_d©a
 
AddsÜ‹dd©a


	)

26 

	#Þly_add_to_li¡
 
AddtÞi¡


	)

27 

	#Þly_©ch_to_aùive_´oûss
 
A‰achtßùiv•roûss


	)

28 

	#Þly_brow£_fž’ame
 
Brow£fž’ame


	)

29 

	#Þly_ü—‹_dump_wšdow
 
C»©edumpwšdow


	)

30 

	#Þly_ü—‹_sÜ‹d_d©a
 
C»©esÜ‹dd©a


	)

31 

	#Þly_de¡roy_sÜ‹d_d©a
 
De¡roysÜ‹dd©a


	)

32 

	#Þly_fšd_moduË
 
FšdmoduË


	)

33 

	#Þly_fšd_sÜ‹d_d©a
 
FšdsÜ‹dd©a


	)

34 

	#Þly_fšd_th»ad
 
Fšdth»ad


	)

35 

	#Þly_g‘_ýu_th»ad_id
 
G‘ýuth»adid


	)

36 

	#Þly_g‘_lÚg
 
G‘lÚg


	)

37 

	#Þly_g‘_hex_¡ršg
 
G‘hex¡ršg


	)

38 

	#Þly_g‘_sÜ‹d_by_£ËùiÚ
 
G‘sÜ‹dby£ËùiÚ


	)

39 

	#Þly_g‘_¡©us
 
G‘¡©us


	)

40 

	#Þly_mes§ge
 
Mes§ge


	)

41 

	#Þly_·št_bË
 
Paš‰abË


	)

42 

	#Þly_quick_bË_wšdow
 
QuickbËwšdow


	)

43 

	#Þly_»ad_memÜy
 
R—dmemÜy


	)

44 

	#Þly_»gi¡”_¶ugš_þass
 
Regi¡”¶ugšþass


	)

45 

	#Þly_bË_funùiÚ
 
TabËfunùiÚ


	)

46 

	#Þly_uÄegi¡”_¶ugš_þass
 
UÄegi¡”¶ugšþass


	)

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\paimei_ollydbg_connector.cpp

22 
	~"¡dafx.h
"

23 
	~<¡dio.h
>

25 
	~"Þly_»defšes.h
"

26 
	~"¶ugš.h
"

27 
	~"·imei_Þlydbg_cÚÃùÜ.h
"

28 
	~"Þly_ÿÎbacks.h
"

34 
	$·imei_cÚÃù
 ()

36 
ho¡’t
 *
he
;

37 
sockaddr_š
 
sš
;

38 
š_addr
 
addr
;

39 
WSADATA
 
w§_d©a
;

41 
£rv”
[256];

43 
	`mem£t
(
£rv”
, 0, (server));

44 
	`¡rýy
(
£rv”
, "127.0.0.1");

47 ià(
cÚÃùiÚ
)

50 ià(
	`G‘‹xt
("PaiMe˜S”v”:", 
£rv”
, 0x00, 
NM_NONAME
, 
FIXEDFONT
) == -1)

54 ià(
	`WSAS¹up
(
	`MAKEWORD
(2, 2), &
w§_d©a
) != 0)

56 
	`Þly_add_to_li¡
(0, 1, "[!] "
PLUGIN_NAME
"> WSAStartup() failed.");

61 ià(
	`LOBYTE
(
w§_d©a
.
wV”siÚ
è!ð2 || 
	`HIBYTE
(wsa_data.wVersion) != 2)

63 
	`WSAC˪up
();

64 
	`Þly_add_to_li¡
(0, 1, 
PLUGIN_NAME
"> Winsock version 2.2‚ot found.");

69 ià(
	`i§Íha
(
£rv”
[0]))

71 ià((
he
 = 
	`g‘ho¡byÇme
(
£rv”
)è=ð
NULL
)

73 
	`Þly_add_to_li¡
(0, 1, "[!] "
PLUGIN_NAME
"> UÇbˁػsÞvÇme: %s", 
£rv”
);

80 
addr
.
s_addr
 = 
	`š‘_addr
(
£rv”
);

82 ià((
he
 = 
	`g‘ho¡byaddr
((*)&
addr
, (
š_addr
), 
AF_INET
)è=ð
NULL
)

84 
	`Þly_add_to_li¡
(0, 1, "[!] "
PLUGIN_NAME
"> Unableo„esolve‡ddress");

90 ià((
cÚÃùiÚ
 = 
	`sock‘
(
AF_INET
, 
SOCK_STREAM
, 
IPPROTO_TCP
)è=ð
INVALID_SOCKET
)

92 
	`WSAC˪up
();

93 
	`Þly_add_to_li¡
(0, 1, "[!] "
PLUGIN_NAME
"> Failedo create socket.");

98 
sš
.
sš_çmžy
 = 
AF_INET
;

99 
sš
.
sš_addr
 = *((
LPIN_ADDR
)*
he
->
h_addr_li¡
);

100 
sš
.
sš_pÜt
 = 
	`htÚs
(7033);

102 ià(
	`cÚÃù
(
cÚÃùiÚ
, (
SOCKADDR
 *è&
sš
, (sš)è=ð
SOCKET_ERROR
)

104 
	`WSAC˪up
();

105 
	`Þly_add_to_li¡
(0, 1, "[!] "
PLUGIN_NAME
"> Failedo connecto server.");

108 
	}
}

115 
	$·imei_xm™_loÿtiÚ
 (
t_dump
 *
pd
)

117 
t_moduË
 *
tmod
;

118 
buf
[128];

119 
size_t
 
Ën
;

121 ià(!
cÚÃùiÚ
)

123 
	`Þly_add_to_li¡
(0, 1, "connecto…aimei„eceiver first.");

127 ià(!
pd
)

129 
	`Þly_add_to_li¡
(0, 1, "no current itemo xmit.");

133 
tmod
 = 
	`Þly_fšd_moduË
(
pd
->
£l0
);

136 
tmod
->
Çme
[
SHORTLEN
] = 0;

138 
	`Þly_add_to_li¡
(0, 0, "%08x i š % ba£d‡ˆ%08x", 
pd
->
£l0
, 
tmod
->
Çme
,mod->
ba£
);

140 
	`¥rštf
(
buf
, "%s:%08x\n", 
tmod
->
Çme
, 
pd
->
£l0
 -mod->
ba£
);

141 
Ën
 = 
	`¡¾’
(
buf
);

144 ià(
	`£nd
(
cÚÃùiÚ
, 
buf
, 
Ën
, 0) !=†en)

146 
	`þo£sock‘
(
cÚÃùiÚ
);

147 
	`WSAC˪up
();

148 
cÚÃùiÚ
 = 
NULL
;

150 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\paimei_ollydbg_connector.h

20 #iâdeà
__OLLY_PAIMEI_CONNECTOR_H__


21 

	#__OLLY_PAIMEI_CONNECTOR_H__


	)

23 #undeà
DEBUG


24 

	#PLUGIN_NAME
 "PaiMe˜CÚÃùÜ"

	)

30 
HINSTANCE
 
	ghš¡
;

31 
HWND
 
	ghwmaš
;

32 
SOCKET
 
	gcÚÃùiÚ
 = 
NULL
;

38 
·imei_cÚÃù
 ();

39 
·imei_xm™_loÿtiÚ
 (
t_dump
 *);

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\plugin.h

33 #ifdeà
__BORLANDC__


35 #´agm¨
ÝtiÚ
 -
a1


36 #´agm¨
ÝtiÚ
 -
K


41 
	st_®igÁe¡
 {

42 
	ma
;

43 
	mb
;

44 } 
	tt_®igÁe¡
;

46 #ià((
t_®igÁe¡
)!=()+())

47 #”rÜ 
PËa£
 
assu»
 
by‹
 
®ignm’t
 
of
 
OÎyDbg
 
¡ruùu»s


49 #undeà
t_®igÁe¡


52 #”rÜ 
PËa£
 
£t
  
ty³
 
to
 

59 #ifdeà
_MSC_VER


61 #´agm¨
·ck
(1)

63 #iâdeà
_CHAR_UNSIGNED


64 #”rÜ 
PËa£
 
£t
  
ty³
 
to
 (
ÝtiÚ
 /
J
)

70 

	#ODBG_Plugšd©a
 
_ODBG_Plugšd©a


	)

71 

	#ODBG_Plugšš™
 
_ODBG_Plugšš™


	)

72 

	#ODBG_PlugšmašloÝ
 
_ODBG_PlugšmašloÝ


	)

73 

	#ODBG_Plugš§veudd
 
_ODBG_Plugš§veudd


	)

74 

	#ODBG_Plugšudd»cÜd
 
_ODBG_Plugšudd»cÜd


	)

75 

	#ODBG_Plugšm’u
 
_ODBG_Plugšm’u


	)

76 

	#ODBG_PlugšaùiÚ
 
_ODBG_PlugšaùiÚ


	)

77 

	#ODBG_PlugšshÜtcut
 
_ODBG_PlugšshÜtcut


	)

78 

	#ODBG_Plugš»£t
 
_ODBG_Plugš»£t


	)

79 

	#ODBG_Plugšþo£
 
_ODBG_Plugšþo£


	)

80 

	#ODBG_Plugšde¡roy
 
_ODBG_Plugšde¡roy


	)

81 

	#ODBG_Pau£d
 
_ODBG_Pau£d


	)

82 

	#ODBG_Pau£dex
 
_ODBG_Pau£dex


	)

83 

	#ODBG_Plugšcmd
 
_ODBG_Plugšcmd


	)

91 

	#PLUGIN_VERSION
 110

92 

	)

93 #ifdeà
__ýlu¥lus


94 

	#extc
 
"C"

95 #–£

	)

96 

	#extc
 

	)

99 

	#_expÜt
 
	`__deþ¥ec
(
dÎexpÜt
)

	)

101 
	tuch¬
;

102 
	tushÜt
;

103 
	tušt
;

104 
	tulÚg
;

106 

	#TEXTLEN
 256

107 

	#ARGLEN
 1024

108 

	#USERLEN
 4096

109 

	#SHORTLEN
 8

110 

	)

111 

	#BLACK
 0

112 

	#BLUE
 1

113 

	#GREEN
 2

114 

	#CYAN
 3

115 

	#RED
 4

	)

116 

	#MAGENTA
 5

	)

117 

	#BROWN
 6

	)

118 

	#LIGHTGRAY
 7

	)

119 

	#DARKGRAY
 8

	)

120 

	#LIGHTBLUE
 9

	)

121 

	#LIGHTGREEN
 10

	)

122 

	#LIGHTCYAN
 11

	)

123 

	#LIGHTRED
 12

	)

124 

	#LIGHTMAGENTA
 13

	)

125 

	#YELLOW
 14

	)

126 

	#WHITE
 15

	)

127 

	#MINT
 16

	)

128 

	#SKYBLUE
 17

	)

129 

	#IVORY
 18

	)

130 

	#GRAY
 19

	)

132 

	#NCOLORS
 20

133 

	)

134 

	#BKTRANSP
 0x00

135 

	#BKBLACK
 0x10

	)

136 

	#BKGRAY
 0x20

	)

137 

	#BKWHITE
 0x30

	)

138 

	#BKCYAN
 0x40

	)

139 

	#BKGREEN
 0x50

	)

140 

	#BKRED
 0x60

	)

141 

	#BKYELLOW
 0x70

	)

143 

	#BLACKWHITE
 0

144 

	#BLUEGOLD
 1

	)

145 

	#SKYWIND
 2

	)

146 

	#NIGHTSTARS
 3

	)

147 

	#SCHEME4
 4

	)

148 

	#SCHEME5
 5

	)

149 

	#SCHEME6
 6

	)

150 

	#SCHEME7
 7

	)

152 

	#FIXEDFONT
 0

153 

	#TERMINAL6
 1

154 

	#FIXEDSYS
 2

155 

	#COURIERFONT
 3

	)

156 

	#LUCIDACONS
 4

	)

157 

	#FONT5
 5

	)

158 

	#FONT6
 6

	)

159 

	#FONT7
 7

	)

160 

	#MAINFONT
 8

	)

161 

	#SYSFONT
 9

	)

162 

	#INFOFONT
 10

	)

167 
extc
 
cdeþ
 
AddtÞi¡
(
addr
,
highlight
,*
fÜm©
,...);

168 
extc
 
cdeþ
 
Upd©–i¡
();

169 
extc
 
HWND
 
cdeþ
 
C»©–i¡wšdow
();

170 
extc
 
cdeþ
 
E¼Ü
(*
fÜm©
,...);

171 
extc
 
cdeþ
 
Mes§ge
(
ulÚg
 
addr
,*
fÜm©
,...);

172 
extc
 
cdeþ
 
InfÞše
(*
fÜm©
,...);

173 
extc
 
cdeþ
 
Prog»ss
(
´omžË
,*
fÜm©
,...);

174 
extc
 
cdeþ
 
FÏsh
(*
fÜm©
,...);

181 

	#ADC_DEFAULT
 0x0000

182 

	#ADC_DIFFMOD
 0x0001

183 

	#ADC_NOMODNAME
 0x0002

184 

	#ADC_VALID
 0x0004

185 

	#ADC_INMODULE
 0x0008

186 

	#ADC_SAMEMOD
 0x0010

187 

	#ADC_SYMBOL
 0x0020

188 

	#ADC_JUMP
 0x0040

189 

	#ADC_OFFSET
 0x0080

190 

	#ADC_STRING
 0x0100

191 

	#ADC_ENTRY
 0x0200

192 

	#ADC_UPPERCASE
 0x0400

193 

	#ADC_WIDEFORM
 0x0800

194 

	#ADC_NONTRIVIAL
 0x1000

195 

	#ADC_DYNAMIC
 0x2000

196 

	)

197 

	#PLAINASCII
 0x01

198 

	#DIACRITICAL
 0x02

199 

	#RAREASCII
 0x10

200 

	)

201 
extc
 
cdeþ
 
Decod—dd»ss
(
ulÚg
 
addr
,ulÚg 
ba£
,
addrmode
,

202 *
symb
,
nsymb
,*
comm’t
);

203 
extc
 
cdeþ
 
Decod”–©iveoff£t
(
ulÚg
 
addr
,
addrmode
,

204 *
symb
,
nsymb
);

205 
extc
 
cdeþ
 
Decodech¬aù”
(*
s
,
ušt
 
c
);

206 
extc
 
cdeþ
 
Prštæßt4
(*
s
,
f
);

207 
extc
 
cdeþ
 
Prštæßt8
(*
s
,
d
);

208 
extc
 
cdeþ
 
Prštæßt10
(*
s
,
ext
);

209 
extc
 
cdeþ
 
Pršt3dnow
(*
s
,
uch¬
 *
f
);

210 
extc
 
cdeþ
 
Pršts£
(*
s
,*
f
);

211 
extc
 
ulÚg
 
cdeþ
 
FÞlowÿÎ
(ulÚg 
addr
);

212 
extc
 
cdeþ
 
I¡extA
(
c
);

213 
extc
 
cdeþ
 
I¡extW
(
wch¬_t
 
w
);

214 
extc
 
cdeþ
 
SŒšgtÙext
(*
d©a
,
nd©a
,*
‹xt
,
Áext
);

219 

	#MAXCMDSIZE
 16

220 

	#NSEQ
 8

221 

	#NMODELS
 8

222 

	)

224 

	#DIA_ASKGLOBAL
 0x0001

225 

	#DIA_HEXONLY
 0x0002

226 

	#DIA_ALIGNED
 0x0004

227 

	#DIA_DEFHEX
 0x0000

228 

	#DIA_DEFASCII
 0x0010

229 

	#DIA_DEFUNICODE
 0x0020

230 

	#DIA_SEARCH
 0x0040

231 

	#DIA_HISTORY
 0x0100

232 

	)

234 

	#ANIMATE_OFF
 0

235 

	#ANIMATE_IN
 1

236 

	#ANIMATE_OVER
 2

237 

	#ANIMATE_RET
 3

238 

	#ANIMATE_SKPRET
 4

239 

	#ANIMATE_USER
 5

240 

	#ANIMATE_TRIN
 6

241 

	#ANIMATE_TROVER
 7

242 

	#ANIMATE_STOP
 8

243 

	)

244 
	st_hex¡r
 {

245 
	mn
;

246 
uch¬
 
	md©a
[
TEXTLEN
];

247 
uch¬
 
	mmask
[
TEXTLEN
];

248 } 
	tt_hex¡r
;

250 
	st_asmmod–
 {

251 
uch¬
 
	mcode
[
MAXCMDSIZE
];

252 
uch¬
 
	mmask
[
MAXCMDSIZE
];

253 
	mËngth
;

254 
	mjmpsize
;

255 
	mjmpoff£t
;

256 
	mjmµos
;

257 } 
	tt_asmmod–
;

259 
	st_extmod–
 {

260 
	mcode
[
MAXCMDSIZE
];

261 
	mmask
[
MAXCMDSIZE
];

262 
	mËngth
;

263 
	mjmpsize
;

264 
	mjmpoff£t
;

265 
	mjmµos
;

266 
	mi§ny
;

267 
	mcmdoff£t
;

268 
	m¿mask
[
MAXCMDSIZE
];

269 
	mrbmask
[
MAXCMDSIZE
];

270 } 
	tt_extmod–
;

272 
extc
 
cdeþ
 
G‘lÚg
(*
t™Ë
,
ulÚg
 *
d©a
,
d©asize
,

273 
ˉ”
,
mode
);

274 
extc
 
cdeþ
 
G‘lÚgxy
(*
t™Ë
,
ulÚg
 *
d©a
,
d©asize
,

275 
ˉ”
,
mode
,
x
,
y
);

276 
extc
 
cdeþ
 
G‘»gxy
(*
t™Ë
,
ulÚg
 *
d©a
,
ˉ”
,
x
,
y
);

277 
extc
 
cdeþ
 
G‘lše
(*
t™Ë
,
ulÚg
 *
d©a
);

278 
extc
 
cdeþ
 
G‘lšexy
(*
t™Ë
,
ulÚg
 *
d©a
,
x
,
y
);

279 
extc
 
cdeþ
 
G‘æßt10
(*
t™Ë
,*
fd©a
,

280 
uch¬
 *
g
,
ˉ”
,
mode
);

281 
extc
 
cdeþ
 
G‘æßt10xy
(*
t™Ë
,*
fd©a
,

282 *
g
,
ˉ”
,
mode
,
x
,
y
);

283 
extc
 
cdeþ
 
G‘æßt
(*
t™Ë
,*
fd©a
,
size
,

284 
ˉ”
,
mode
);

285 
extc
 
cdeþ
 
G‘æßtxy
(*
t™Ë
,*
fd©a
,
size
,

286 
ˉ”
,
mode
,
x
,
y
);

287 
extc
 
cdeþ
 
G‘asmfšdmod–
(
t_asmmod–
 
mod–
[
NMODELS
],

288 
ˉ”
,
£¬ch®l
);

289 
extc
 
cdeþ
 
G‘asmfšdmod–xy
(
t_asmmod–
 
mod–
[
NMODELS
],

290 
ˉ”
,
£¬ch®l
,
x
,
y
);

291 
extc
 
cdeþ
 
G‘‹xt
(*
t™Ë
,*
‹xt
,

292 
ˉ”
,
ty³
,
fÚtšdex
);

293 
extc
 
cdeþ
 
G‘‹xtxy
(*
t™Ë
,*
‹xt
,
ˉ”
,

294 
ty³
,
fÚtšdex
,
x
,
y
);

295 
extc
 
cdeþ
 
G‘hex¡ršg
(*
t™Ë
,
t_hex¡r
 *
hs
,

296 
mode
,
fÚtšdex
,
ˉ”
);

297 
extc
 
cdeþ
 
G‘hex¡ršgxy
(*
t™Ë
,
t_hex¡r
 *
hs
,
mode
,

298 
fÚtšdex
,
ˉ”
,
x
,
y
);

299 
extc
 
cdeþ
 
G‘mmx
(*
t™Ë
,
uch¬
 *
d©a
,
mode
);

300 
extc
 
cdeþ
 
G‘mmxxy
(*
t™Ë
,*
d©a
,
mode
,
x
,
y
);

301 
extc
 
cdeþ
 
G‘3dnow
(*
t™Ë
,
uch¬
 *
d©a
,
mode
);

302 
extc
 
cdeþ
 
G‘3dnowxy
(*
t™Ë
,*
d©a
,
mode
,
x
,
y
);

303 
extc
 
cdeþ
 
Brow£fž’ame
(*
t™Ë
,*
Çme
,*
deãxt
,

304 
g‘¬gum’ts
);

305 
extc
 
cdeþ
 
O³nEXEfže
(*
·th
,
drݳd
);

306 
extc
 
cdeþ
 
A‰achtßùiv•roûss
(
Ãw´oûssid
);

307 
extc
 
cdeþ
 
Anim©e
(
ªim©iÚ
);

312 

	#NBAR
 17

313 

	)

314 

	#BAR_PRESSED
 0x01

315 

	#BAR_DISABLED
 0x02

316 

	#BAR_NOSORT
 0x04

317 

	#BAR_NORESIZE
 0x08

318 

	#BAR_BUTTON
 0x10

319 

	#BAR_SHIFTSEL
 0x20

320 

	)

321 

	#CAPT_FREE
 0

322 

	)

323 

	#TABLE_DIR
 0x0001

324 

	#TABLE_COPYMENU
 0x0002

325 

	#TABLE_SORTMENU
 0x0004

326 

	#TABLE_APPMENU
 0x0010

327 

	#TABLE_WIDECOL
 0x0020

328 

	#TABLE_USERAPP
 0x0040

329 

	#TABLE_USERDEF
 0x0080

330 

	#TABLE_NOHSCR
 0x0100

331 

	#TABLE_SAVEPOS
 0x0200

332 

	#TABLE_CPU
 0x0400

333 

	#TABLE_FASTSEL
 0x0800

334 

	#TABLE_COLSEL
 0x1000

335 

	#TABLE_SAVEAPP
 0x2000

336 

	#TABLE_HILMENU
 0x4000

337 

	#TABLE_ONTOP
 0x8000

338 

	)

339 

	#DRAW_NORMAL
 0x0000

340 

	#DRAW_GRAY
 0x0001

341 

	#DRAW_HILITE
 0x0002

342 

	#DRAW_UL
 0x0004

343 

	#DRAW_SELECT
 0x0008

344 

	#DRAW_EIP
 0x0010

345 

	#DRAW_BREAK
 0x0020

346 

	#DRAW_GRAPH
 0x0040

347 

	#DRAW_DIRECT
 0x0080

348 

	#DRAW_MASK
 0x0080

349 

	#DRAW_EXTSEL
 0x0100

350 

	#DRAW_UNICODE
 0x0200

351 

	#DRAW_TOP
 0x0400

352 

	#DRAW_BOTTOM
 0x0800

353 

	)

356 

	#D_SPACE
 'N'

357 

	#D_SEP
 ' '

358 

	#D_BEGIN
 'B'

359 

	#D_BODY
 'I'

360 

	#D_ENTRY
 'J'

361 

	#D_LEAF
 'K'

362 

	#D_END
 'E'

363 

	#D_SINGLE
 'S'

364 

	#D_ENDBEG
 'T'

365 

	#D_POINT
 '.'

366 

	#D_JMPUP
 'U'

367 

	#D_JMPOUT
 '<'

368 

	#D_JMPDN
 'D'

369 

	#D_PATHUP
 'u'

370 

	#D_GRAYUP
 'v'

371 

	#D_PATH
 'i'

372 

	#D_GRAYPATH
 'j'

373 

	#D_PATHDN
 'd'

374 

	#D_GRAYDN
 'e'

375 

	#D_PATHUPEND
 'r'

376 

	#D_GRAYUPEND
 's'

377 

	#D_PATHDNEND
 'f'

378 

	#D_GRAYDNEND
 'g'

379 

	#D_SWTOP
 't'

380 

	#D_SWBODY
 'b'

381 

	#D_CASE
 'c'

382 

	#D_LASTCASE
 'l'

383 

	)

388 

	#TY_NEW
 0x00000001

389 

	#TY_CONFIRMED
 0x00000002

390 

	#TY_MAIN
 0x00000004

391 

	#TY_INVALID
 0x00000008

392 

	#TY_SELECTED
 0x80000000

394 

	#TY_REPORTED
 0x00000010

396 

	#TY_REFERENCE
 0x00000020

397 

	#TY_ORIGIN
 0x00000040

399 

	#TY_STOPAN
 0x00000080

400 

	#TY_SET
 0x00000100

401 

	#TY_ACTIVE
 0x00000200

402 

	#TY_DISABLED
 0x00000400

403 

	#TY_ONESHOT
 0x00000800

404 

	#TY_TEMP
 0x00001000

405 

	#TY_KEEPCODE
 0x00002000

406 

	#TY_KEEPCOND
 0x00004000

407 

	#TY_NOUPDATE
 0x00008000

408 

	#TY_RTRACE
 0x00010000

410 

	#TY_EXPORT
 0x00010000

411 

	#TY_IMPORT
 0x00020000

412 

	#TY_LIBRARY
 0x00040000

413 

	#TY_LABEL
 0x00080000

414 

	#TY_ANYNAME
 0x000F0000

415 

	#TY_KNOWN
 0x00100000

417 

	#TY_DEFHEAP
 0x00020000

418 

	#TY_HEAP
 0x00040000

419 

	#TY_SFX
 0x00080000

420 

	#TY_CODE
 0x00100000

421 

	#TY_DATA
 0x00200000

422 

	#TY_IMPDATA
 0x00400000

423 

	#TY_EXPDATA
 0x00800000

424 

	#TY_RSRC
 0x01000000

425 

	#TY_RELOC
 0x02000000

426 

	#TY_STACK
 0x04000000

427 

	#TY_THREAD
 0x08000000

428 

	#TY_HEADER
 0x10000000

429 

	#TY_ANYMEM
 0x1FFE0000

430 

	#TY_GUARDED
 0x20000000

432 

	#TY_PURE
 0x00004000

433 

	#TY_PASCAL
 0x00010000

434 

	#TY_C
 0x00020000

435 

	#TY_NOTENTRY
 0x00100000

437 

	#TY_CHARSW
 0x00100000

438 

	#TY_WMSW
 0x00200000

439 

	#TY_EXCEPTSW
 0x00400000

441 

	#TY_RELIABLE
 0x01000000

442 

	#TY_GUESSED
 0x02000000

443 

	#TY_BELONGS
 0x04000000

445 

	#TY_RECURSIVE
 0x00000100

446 

	#TY_TERMINAL
 0x00000200

447 

	#TY_SYSTEM
 0x00000400

448 

	#TY_DIRECT
 0x00000800

449 

	#TY_NODATA
 0x00001000

450 

	#TY_DUMMY
 0x00002000

451 

	#TY_NOSIDE
 0x00004000

452 

	)

453 
	st_scheme
 {

454 *
	mÇme
;

455 
	m‹xtcÞÜ
;

456 
	mh™extcÞÜ
;

457 
	mlowcÞÜ
;

458 
	mbkcÞÜ
;

459 
	m£lbkcÞÜ
;

460 
	mlšecÞÜ
;

461 
	mauxcÞÜ
;

462 
	mcÚdbkcÞÜ
;

463 } 
	tt_scheme
;

465 
	st_schemeÝt
 {

466 *
	mÇme
;

467 
	mcÞÜ
[8];

468 } 
	tt_schemeÝt
;

470 
	st_b¬
 {

471 
	mnb¬
;

472 
	mfÚt
;

473 
	mdx
[
NBAR
];

474 
	mdefdx
[
NBAR
];

475 *
	mÇme
[
NBAR
];

476 
uch¬
 
	mmode
[
NBAR
];

477 
	mÿ±u»d
;

478 
	maùive
;

479 
	m´evx
;

480 } 
	tt_b¬
;

482 
	st_sÜth—d”
 {

483 
ulÚg
 
	maddr
;

484 
ulÚg
 
	msize
;

485 
ulÚg
 
	mty³
;

486 } 
	tt_sÜth—d”
;

488 
	tSORTFUNC
(cÚ¡ 
	tt_sÜth—d”
 *,const_sortheader *,const );

489 
	tDRAWFUNC
(*,*,*,
	tt_sÜth—d”
 *,);

490 
	tDESTFUNC
(
	tt_sÜth—d”
 *);

492 

	#AUTOARRANGE
 ((
SORTFUNC
 *)1)

493 

	)

494 
	st_s܋d
 {

495 
	mÇme
[
MAX_PATH
];

496 
	mn
;

497 
	mnmax
;

498 
	m£Ëùed
;

499 
ulÚg
 
	m£Ïddr
;

500 
	m™emsize
;

501 
ulÚg
 
	mv”siÚ
;

502 *
	md©a
;

503 
SORTFUNC
 *
	msÜtfunc
;

504 
DESTFUNC
 *
	mde¡func
;

505 
	msÜt
;

506 
	ms܋d
;

507 *
	mšdex
;

508 
	msuµ»s£¼
;

509 } 
	tt_s܋d
;

511 
	st_bË
 {

512 
HWND
 
	mhw
;

513 
t_s܋d
 
	md©a
;

514 
t_b¬
 
	mb¬
;

515 
	mshowb¬
;

516 
	mhsüÞl
;

517 
	mcÞ£l
;

518 
	mmode
;

519 
	mfÚt
;

520 
	mscheme
;

521 
	mhž™e
;

522 
	moff£t
;

523 
	mxshiá
;

524 
DRAWFUNC
 *
	md¿wfunc
;

525 } 
	tt_bË
;

527 
extc
 
cdeþ
 
C»©esÜ‹dd©a
(
t_s܋d
 *
sd
,*
Çme
,
™emsize
,

528 
nmax
,
SORTFUNC
 *
sÜtfunc
,
DESTFUNC
 *
de¡func
);

529 
extc
 
cdeþ
 
De¡roysÜ‹dd©a
(
t_s܋d
 *
sd
);

530 
extc
 
cdeþ
 *
AddsÜ‹dd©a
(
t_s܋d
 *
sd
,*
™em
);

531 
extc
 
cdeþ
 
D–‘esÜ‹dd©a
(
t_s܋d
 *
sd
,
ulÚg
 
addr
);

532 
extc
 
cdeþ
 
D–‘esÜ‹dd©¬ªge
(
t_s܋d
 *
sd
,
ulÚg
 
addr0
,ulÚg 
addr1
);

533 
extc
 
cdeþ
 
D–‘’ÚcÚfœmedsÜ‹dd©a
(
t_s܋d
 *
sd
);

534 
extc
 * 
cdeþ
 
FšdsÜ‹dd©a
(
t_s܋d
 *
sd
,
ulÚg
 
addr
);

535 
extc
 * 
cdeþ
 
FšdsÜ‹dd©¬ªge
(
t_s܋d
 *
sd
,
ulÚg
 
addr0
,ulÚg 
addr1
);

536 
extc
 
cdeþ
 
FšdsÜ‹dd©ašdex
(
t_s܋d
 *
sd
,
ulÚg
 
addr0
,ulÚg 
addr1
);

537 
extc
 
cdeþ
 
SÜtsÜ‹dd©a
(
t_s܋d
 *
sd
,
sÜt
);

538 
extc
 * 
cdeþ
 
G‘sÜ‹dby£ËùiÚ
(
t_s܋d
 *
sd
,
šdex
);

539 
extc
 
cdeþ
 
DeçuÉb¬
(
t_b¬
 *
pb
);

540 
extc
 
cdeþ
 
TabËfunùiÚ
(
t_bË
 *
±
,

541 
HWND
 
hw
,
UINT
 
msg
,
WPARAM
 
wp
,
LPARAM
 
Í
);

542 
extc
 
cdeþ
 
Paš‰abË
(
HWND
 
hw
,
t_bË
 *
±
,
DRAWFUNC
 
g‘lše
);

543 
extc
 
cdeþ
 
G‘bË£ËùiÚxy
(
t_bË
 *
±
,
cÞumn
,*
px
,*
py
);

544 
extc
 
cdeþ
 
S–eùªdsüÞl
(
t_bË
 *
±
,
šdex
,
mode
);

551 

	#NM_NONAME
 0x00

552 

	#NM_ANYNAME
 0xFF

554 

	#NM_PLUGCMD
 0x30

555 

	#NM_LABEL
 0x31

556 

	#NM_EXPORT
 0x32

557 

	#NM_IMPORT
 0x33

558 

	#NM_LIBRARY
 0x34

559 

	#NM_CONST
 0x35

560 

	#NM_COMMENT
 0x36

561 

	#NM_LIBCOMM
 0x37

562 

	#NM_BREAK
 0x38

563 

	#NM_ARG
 0x39

564 

	#NM_ANALYSE
 0x3A

565 

	#NM_BREAKEXPR
 0x3B

566 

	#NM_BREAKEXPL
 0x3C

567 

	#NM_ASSUME
 0x3D

568 

	#NM_STRUCT
 0x3E

569 

	#NM_CASE
 0x3F

571 

	#NM_INSPECT
 0x40

572 

	#NM_WATCH
 0x41

573 

	#NM_ASM
 0x42

574 

	#NM_FINDASM
 0x43

575 

	#NM_LASTWATCH
 0x48

576 

	#NM_SOURCE
 0x49

577 

	#NM_REFTXT
 0x4A

578 

	#NM_GOTO
 0x4B

579 

	#NM_GOTODUMP
 0x4C

580 

	#NM_TRPAUSE
 0x4D

582 

	#NM_IMCALL
 0xFE

583 

	)

584 

	#NMHISTORY
 0x40

585 

	)

586 
extc
 
cdeþ
 
In£¹Çme
(
ulÚg
 
addr
,
ty³
,*
Çme
);

587 
extc
 
cdeþ
 
Quickš£¹Çme
(
ulÚg
 
addr
,
ty³
,*
Çme
);

588 
extc
 
cdeþ
 
M”gequickÇmes
();

589 
extc
 
cdeþ
 
DisÿrdquickÇmes
();

590 
extc
 
cdeþ
 
FšdÇme
(
ulÚg
 
addr
,
ty³
,*
Çme
);

591 
extc
 
cdeþ
 
Decod’ame
(
ulÚg
 
addr
,
ty³
,*
Çme
);

592 
extc
 
ulÚg
 
cdeþ
 
FšdÃxŠame
(*
Çme
);

593 
extc
 
cdeþ
 
FšdÏb–
(
ulÚg
 
addr
,*
Çme
);

594 
extc
 
cdeþ
 
D–‘’am”ªge
(
ulÚg
 
addr0
,ulÚg 
addr1
,
ty³
);

595 
extc
 
cdeþ
 
FšdÏb–byÇme
(*
Çme
,
ulÚg
 *
addr
,

596 
ulÚg
 
addr0
,ulÚg 
addr1
);

597 
extc
 
ulÚg
 
cdeþ
 
FšdimpÜtbyÇme
(*
Çme
,ulÚg 
addr0
,ulÚg 
addr1
);

598 
extc
 
cdeþ
 
DemªgËÇme
(*
Çme
,
ty³
,*
undecܩed
);

599 
extc
 
cdeþ
 
FšdsymbÞiúame
(
ulÚg
 
addr
,*
âame
);

604 

	#REG_EAX
 0

605 

	#REG_ECX
 1

606 

	#REG_EDX
 2

	)

607 

	#REG_EBX
 3

	)

608 

	#REG_ESP
 4

	)

609 

	#REG_EBP
 5

	)

610 

	#REG_ESI
 6

	)

611 

	#REG_EDI
 7

	)

613 

	#SEG_UNDEF
 -1

	)

614 

	#SEG_ES
 0

615 

	#SEG_CS
 1

616 

	#SEG_SS
 2

	)

617 

	#SEG_DS
 3

	)

618 

	#SEG_FS
 4

	)

619 

	#SEG_GS
 5

	)

622 

	#RS_NONE
 0x0000

623 

	#RS_INT
 0x0010

624 

	#RS_EIP
 0x0020

625 

	#RS_FLG
 0x0030

626 

	#RS_SEG
 0x0040

627 

	#RS_EFL
 0x0050

628 

	#RS_TAG
 0x0060

629 

	#RS_FPU
 0x0070

630 

	#RS_FST
 0x0080

631 

	#RS_FCO
 0x0090

632 

	#RS_FER
 0x00A0

633 

	#RS_FCW
 0x00B0

634 

	#RS_FPR
 0x00C0

635 

	#RS_FEM
 0x00D0

636 

	#RS_MMX
 0x00E0

637 

	#RS_3DN
 0x00F0

638 

	#RS_SSE
 0x0100

639 

	#RS_CSR
 0x0110

640 

	#RS_CSB
 0x0120

641 

	#RS_CPR
 0x0130

642 

	#RS_ERR
 0x0140

643 

	)

644 

	#RS_GROUP
 0x01F0

645 

	#RS_INDEX
 0x000F

646 

	)

647 

	#NREGSTACK
 32

648 

	#MAXCALSIZE
 8

649 

	)

650 

	#INT3
 0xCC

651 

	#NOP
 0x90

652 

	#TRAPFLAG
 0x00000100

653 

	)

654 

	#C_TYPEMASK
 0xF0

655 

	#C_CMD
 0x00

656 

	#C_PSH
 0x10

657 

	#C_POP
 0x20

658 

	#C_MMX
 0x30

659 

	#C_FLT
 0x40

660 

	#C_JMP
 0x50

661 

	#C_JMC
 0x60

662 

	#C_CAL
 0x70

663 

	#C_RET
 0x80

664 

	#C_FLG
 0x90

665 

	#C_RTF
 0xA0

666 

	#C_REP
 0xB0

667 

	#C_PRI
 0xC0

668 

	#C_SSE
 0xD0

669 

	#C_NOW
 0xE0

670 

	#C_BAD
 0xF0

671 

	#C_RARE
 0x08

672 

	#C_SIZEMASK
 0x07

673 

	#C_EXPL
 0x01

674 

	)

675 

	#C_DANGER95
 0x01

676 

	#C_DANGER
 0x03

677 

	#C_DANGERLOCK
 0x07

678 

	)

679 

	#DEC_TYPEMASK
 0x1F

680 

	#DEC_UNKNOWN
 0x00

681 

	#DEC_BYTE
 0x01

682 

	#DEC_WORD
 0x02

683 

	#DEC_NEXTDATA
 0x03

684 

	#DEC_DWORD
 0x04

685 

	#DEC_FLOAT4
 0x05

686 

	#DEC_FWORD
 0x06

687 

	#DEC_FLOAT8
 0x07

688 

	#DEC_QWORD
 0x08

689 

	#DEC_FLOAT10
 0x09

690 

	#DEC_TBYTE
 0x0A

691 

	#DEC_STRING
 0x0B

692 

	#DEC_UNICODE
 0x0C

693 

	#DEC_3DNOW
 0x0D

694 

	#DEC_SSE
 0x0E

695 

	#DEC_TEXT
 0x10

696 

	#DEC_BYTESW
 0x11

697 

	#DEC_NEXTCODE
 0x13

698 

	#DEC_COMMAND
 0x1D

699 

	#DEC_JMPDEST
 0x1E

700 

	#DEC_CALLDEST
 0x1F

701 

	#DEC_PROCMASK
 0x60

702 

	#DEC_PROC
 0x20

703 

	#DEC_PBODY
 0x40

704 

	#DEC_PEND
 0x60

705 

	#DEC_CHECKED
 0x80

706 

	#DEC_SIGNED
 0x100

707 

	)

708 

	#DISASM_SIZE
 0

709 

	#DISASM_DATA
 1

710 

	#DISASM_TRACE
 2

711 

	#DISASM_FILE
 3

712 

	#DISASM_CODE
 4

713 

	#DISASM_ALL
 5

714 

	#DISASM_RTRACE
 6

715 

	)

716 

	#DISASM_MODE
 0x0000000F

717 

	#DISASM_HILITE
 0x000F0000

718 

	#DISASM_HLSHIFT
 16

719 

	)

721 

	#DAW_FARADDR
 0x0001

722 

	#DAW_SEGMENT
 0x0002

723 

	#DAW_PRIV
 0x0004

724 

	#DAW_IO
 0x0008

725 

	#DAW_SHIFT
 0x0010

726 

	#DAW_PREFIX
 0x0020

727 

	#DAW_LOCK
 0x0040

728 

	#DAW_STACK
 0x0080

729 

	#DAW_DANGER95
 0x1000

730 

	#DAW_DANGEROUS
 0x3000

731 

	)

732 

	#RST_INVALID
 0

733 

	#RST_VALUE
 1

734 

	#RST_VFIXUP
 2

735 

	#RST_INDIRECT
 3

736 

	)

737 

	#NREGSTACK
 32

738 

	)

739 
	st_»g
 {

740 
	mmodif›d
;

741 
	mmodif›dbyu£r
;

742 
	msšgË¡•
;

743 
ulÚg
 
	mr
[8];

744 
ulÚg
 
	m
;

745 
ulÚg
 
	mæags
;

746 
	mtÝ
;

747 
	mf
[8];

748 
	mg
[8];

749 
ulÚg
 
	mf¡
;

750 
ulÚg
 
	mfcw
;

751 
ulÚg
 
	ms
[6];

752 
ulÚg
 
	mba£
[6];

753 
ulÚg
 
	mlim™
[6];

754 
	mbig
[6];

755 
ulÚg
 
	mdr6
;

756 
ulÚg
 
	mth»adid
;

757 
ulÚg
 
	mÏ¡”rÜ
;

758 
	ms£v®id
;

759 
	ms£modif›d
;

760 
	ms£»g
[8][16];

761 
ulÚg
 
	mmxc¤
;

762 
	m£Ëùed
;

763 
ulÚg
 
	md¾š
[4];

764 
ulÚg
 
	mdr7
;

765 } 
	tt_»g
;

767 
	st_Ý”ªd
 {

768 
	mÝty³
;

769 
	mÝsize
;

770 
	m»gsÿË
[8];

771 
	m£g
;

772 
ulÚg
 
	mÝcÚ¡
;

773 } 
	tt_Ý”ªd
;

775 
	st_di§sm
 {

776 
ulÚg
 
	m
;

777 
	mdump
[
TEXTLEN
];

778 
	m»suÉ
[
TEXTLEN
];

779 
	mcomm’t
[
TEXTLEN
];

780 
	mÝšfo
[3][
TEXTLEN
];

781 
	mcmdty³
;

782 
	mmemty³
;

783 
	mŻfix
;

784 
	mšdexed
;

785 
ulÚg
 
	mjmpcÚ¡
;

786 
ulÚg
 
	mjm±abË
;

787 
ulÚg
 
	madrcÚ¡
;

788 
ulÚg
 
	mimmcÚ¡
;

789 
	mz”ocÚ¡
;

790 
	mfixupoff£t
;

791 
	mfixupsize
;

792 
ulÚg
 
	mjm·ddr
;

793 
	mcÚd™iÚ
;

794 
	m”rÜ
;

795 
	mw¬nšgs
;

796 
	mÝty³
[3];

797 
	mÝsize
[3];

798 
	mÝgood
[3];

799 
ulÚg
 
	mÝaddr
[3];

800 
ulÚg
 
	mÝd©a
[3];

801 
t_Ý”ªd
 
	mÝ
[3];

802 
ulÚg
 
	m»gd©a
[8];

803 
	m»g¡©us
[8];

804 
ulÚg
 
	maddrd©a
;

805 
	maddr¡©us
;

806 
ulÚg
 
	m»g¡ack
[
NREGSTACK
];

807 
	mr¡¡©us
[
NREGSTACK
];

808 
	mÄeg¡ack
;

809 
ulÚg
 
	mȣrved
[29];

810 } 
	tt_di§sm
;

812 
extc
 
ulÚg
 
cdeþ
 
Di§sm
(
uch¬
 *
¤c
,ulÚg 
¤csize
,ulÚg 
¤c
,uch¬ *
¤cdec
,

813 
t_di§sm
 *
di§sm
,
di§smmode
,
ulÚg
 
th»adid
);

814 
extc
 
ulÚg
 
cdeþ
 
Di§s£mbËback
(
uch¬
 *
block
,ulÚg 
ba£
,ulÚg 
size
,

815 
ulÚg
 

,
n
,
u£dec
);

816 
extc
 
ulÚg
 
cdeþ
 
Di§s£mbËfÜw¬d
(
uch¬
 *
block
,ulÚg 
ba£
,ulÚg 
size
,

817 
ulÚg
 

,
n
,
u£dec
);

818 
extc
 
cdeþ
 
Issu¥icious
(*
cmd
,
ulÚg
 
size
,ulÚg 

,

819 
ulÚg
 
th»adid
,
t_»g
 *
´eg
,*
s
);

820 
extc
 
cdeþ
 
Isfžlšg
(
ulÚg
 
off£t
,*
d©a
,ulÚg 
size
,ulÚg 
®ign
);

825 
extc
 
cdeþ
 
As£mbË
(*
cmd
,
ulÚg
 

,
t_asmmod–
 *
mod–
,
©‹m±
,

826 
cÚ¡size
,*
”¹ext
);

827 
extc
 
cdeþ
 
CheckcÚd™iÚ
(
code
,
ulÚg
 
æags
);

832 
	st_»suÉ
 {

833 
	mty³
;

834 
	mdty³
;

836 
uch¬
 
	md©a
[10];

837 
ulÚg
 
	mu
;

838 
	ml
;

839 
	mf
; };

841 
	mv®ue
[
TEXTLEN
];

842 
wch¬_t
 
	mwv®ue
[
TEXTLEN
/2]; };

843 
ulÚg
 
	mlvaddr
;

844 } 
	tt_»suÉ
;

846 
extc
 
cdeþ
 
Ex´essiÚ
(
t_»suÉ
 *
»suÉ
,*
ex´essiÚ
,
a
,
b
,

847 
uch¬
 *
d©a
,
ulÚg
 
d©aba£
,ulÚg 
d©asize
,ulÚg 
th»adid
);

852 
	st_th»ad
 {

853 
ulÚg
 
	mth»adid
;

854 
ulÚg
 
	mdummy
;

855 
ulÚg
 
	mty³
;

856 
HANDLE
 
	mth»ad
;

857 
ulÚg
 
	md©ablock
;

858 
ulÚg
 
	m’Œy
;

859 
ulÚg
 
	m¡acktÝ
;

860 
ulÚg
 
	m¡ackbÙtom
;

861 
CONTEXT
 
	mcÚ‹xt
;

862 
t_»g
 
	m»g
;

863 
	m»gv®id
;

864 
t_»g
 
	mÞd»g
;

865 
	mÞd»gv®id
;

866 
	msu¥’dcouÁ
;

867 
	mu£¹ime
;

868 
	msy¡ime
;

869 
ulÚg
 
	mȣrved
[16];

870 } 
	tt_th»ad
;

872 
extc
 
HWND
 
cdeþ
 
C»©‘h»adwšdow
();

873 
extc
 
t_th»ad
* 
cdeþ
 
Fšdth»ad
(
ulÚg
 
th»adid
);

874 
extc
 
cdeþ
 
Decod‘h»adÇme
(*
s
,
ulÚg
 
th»adid
,
mode
);

875 
extc
 
ulÚg
 
cdeþ
 
G‘ýuth»adid
();

876 
extc
 
ulÚg
 
cdeþ
 
RunsšgËth»ad
(ulÚg 
th»adid
);

877 
extc
 
cdeþ
 
Re¡Ü—Îth»ads
();

884 

	#MM_RESTORE
 0x01

885 

	#MM_SILENT
 0x02

886 

	#MM_DELANAL
 0x04

887 

	)

888 

	#MM_RESILENT
 (
MM_RESTORE
|
MM_SILENT
)

	)

890 
	st_memÜy
 {

891 
ulÚg
 
	mba£
;

892 
ulÚg
 
	msize
;

893 
ulÚg
 
	mty³
;

894 
ulÚg
 
	mowÃr
;

895 
ulÚg
 
	mš™acûss
;

896 
ulÚg
 
	macûss
;

897 
ulÚg
 
	mth»adid
;

898 
	m£ù
[
SHORTLEN
];

899 
uch¬
 *
	mcÝy
;

900 
ulÚg
 
	mȣrved
[8];

901 } 
	tt_memÜy
;

903 
	st_h—p
 {

904 
ulÚg
 
	mba£
;

905 
ulÚg
 
	msize
;

906 
ulÚg
 
	mty³
;

907 
ulÚg
 
	m·»Á
;

908 } 
	tt_h—p
;

910 
extc
 
cdeþ
 
Li¡memÜy
();

911 
extc
 
t_memÜy
* 
cdeþ
 
FšdmemÜy
(
ulÚg
 
addr
);

912 
extc
 
cdeþ
 
Gu¬dmemÜy
(
ulÚg
 
ba£
,ulÚg 
size
,
gu¬d
);

913 
extc
 
cdeþ
 
HavecÝyofmemÜy
(
uch¬
 *
cÝy
,
ulÚg
 
ba£
,ulÚg 
size
);

914 
extc
 
ulÚg
 
cdeþ
 
R—dmemÜy
(*
buf
,ulÚg 
addr
,ulÚg 
size
,
mode
);

915 
extc
 
ulÚg
 
cdeþ
 
Wr™ememÜy
(*
buf
,ulÚg 
addr
,ulÚg 
size
,
mode
);

916 
extc
 
ulÚg
 
cdeþ
 
R—dcommªd
(ulÚg 

,*
cmd
);

921 

	#NVERS
 32

922 

	)

924 

	#JT_JUMP
 0

925 

	#JT_COND
 1

926 

	#JT_SWITCH
 2

927 

	)

928 
	st_ahšt
 {

929 
ulÚg
 
	maddr
;

930 
ulÚg
 
	msize
;

931 
ulÚg
 
	mty³
;

932 } 
	tt_ahšt
;

934 
	st_¡ršgbË
 {

935 
ulÚg
 
	mÇme
;

936 
ulÚg
 
	mÏnguage
;

937 
ulÚg
 
	maddr
;

938 
ulÚg
 
	msize
;

939 } 
	tt_¡ršgbË
;

941 
	st_fixup
 {

942 
ulÚg
 
	mba£
;

943 
ulÚg
 
	msize
;

944 } 
	tt_fixup
;

946 
	st_symv¬
 {

947 
	mÃxt
;

948 
ushÜt
 
	mkšd
;

950 
ulÚg
 
	mty³
;

951 
ulÚg
 
	m»gs
; };

953 
ulÚg
 
	maddr
;

954 
	moff£t
; };

955 
ulÚg
 
	msize
;

956 
	mÝtv¬
;

957 
ulÚg
 
	mÇm—ddr
;

958 } 
	tt_symv¬
;

960 
	st_jde¡
 {

961 
	mty³
;

962 
ulÚg
 
	mäom
;

963 
ulÚg
 
	mto
;

964 } 
	tt_jde¡
;

966 
	st_moduË
 {

967 
ulÚg
 
	mba£
;

968 
ulÚg
 
	msize
;

969 
ulÚg
 
	mty³
;

970 
ulÚg
 
	mcodeba£
;

971 
ulÚg
 
	mcodesize
;

972 
ulÚg
 
	m»sba£
;

973 
ulÚg
 
	m»ssize
;

974 
t_¡ršgbË
 *
	m¡ršgbË
;

975 
	mn¡ršgbË
;

976 
	mmax¡ršgbË
;

977 
ulÚg
 
	m’Œy
;

978 
ulÚg
 
	md©aba£
;

979 
ulÚg
 
	mid©©abË
;

980 
ulÚg
 
	mid©aba£
;

981 
ulÚg
 
	med©©abË
;

982 
ulÚg
 
	med©asize
;

983 
ulÚg
 
	m»loùabË
;

984 
ulÚg
 
	m»locsize
;

985 
	mÇme
[
SHORTLEN
];

986 
	m·th
[
MAX_PATH
];

987 
	mn£ù
;

988 
IMAGE_SECTION_HEADER
 *
	m£ù
;

989 
ulÚg
 
	mh—d”size
;

990 
ulÚg
 
	mfixupba£
;

991 
	mnfixup
;

992 
t_fixup
 *
	mfixup
;

993 *
	mcodedec
;

994 
ulÚg
 
	mcodeüc
;

995 *
	mh™Œaû
;

996 *
	mh™ŒaûcÝy
;

997 *
	md©adec
;

998 
t_bË
 
	mÇm–i¡
;

999 
t_symv¬
 *
	msymv¬
;

1000 
	mnsymv¬
;

1001 
	mmaxsymv¬
;

1002 *
	mglob®ty³s
;

1003 
ulÚg
 
	mmaš’Œy
;

1004 
ulÚg
 
	m»®sfx’Œy
;

1005 
	mupd©’am–i¡
;

1006 
ulÚg
 
	mÜigcodesize
;

1007 
ulÚg
 
	msfxba£
;

1008 
ulÚg
 
	msfxsize
;

1009 
	missy¡emdÎ
;

1010 
	m´oûs£d
;

1011 
	mdbgh–psym
;

1012 
	mv”siÚ
[
NVERS
];

1013 
t_jde¡
 *
	mjdd©a
;

1014 
	mnjdd©a
;

1015 
ulÚg
 
	mȣrved
[15];

1016 } 
	tt_moduË
;

1018 
extc
 
t_moduË
* 
cdeþ
 
FšdmoduË
(
ulÚg
 
addr
);

1019 
extc
 
t_fixup
* 
cdeþ
 
Fšdfixup
(
t_moduË
 *
pmod
,
ulÚg
 
addr
);

1020 
extc
 
uch¬
* 
cdeþ
 
Fšddecode
(
ulÚg
 
addr
,ulÚg *
psize
);

1021 
extc
 
ulÚg
 
cdeþ
 
Fšdfžeoff£t
(
t_moduË
 *
pmod
,ulÚg 
addr
);

1022 
extc
 
cdeþ
 
Decodӻge
(
ulÚg
 
addr
,ulÚg 
size
,*
s
);

1023 
extc
 
cdeþ
 
AÇly£code
(
t_moduË
 *
pm
);

1029 

	#DU_ESCAPABLE
 0x20000L

1030 

	#DU_BACKUP
 0x10000L

1031 

	#DU_TYPE
 0x0F000L

1032 

	#DU_COUNT
 0x00FF0L

1033 

	#DU_SIZE
 0x0000FL

1034 

	)

1035 

	#DU_UNDEF
 0x00000L

1036 

	#DU_HEXTEXT
 0x01000L

1037 

	#DU_TEXT
 0x02000L

1038 

	#DU_UNICODE
 0x03000L

1039 

	#DU_INT
 0x04000L

1040 

	#DU_UINT
 0x05000L

1041 

	#DU_IHEX
 0x06000L

1042 

	#DU_FLOAT
 0x07000L

1043 

	#DU_ADDR
 0x08000L

1044 

	#DU_DISASM
 0x09000L

1045 

	#DU_HEXUNI
 0x0A000L

1046 

	#DU_ADRASC
 0x0B000L

1047 

	#DU_ADRUNI
 0x0C000L

1048 

	#DU_SPEC
 0x0D000L

1049 

	)

1051 

	#MT_BACKUP
 0x0001

1052 

	#MT_COPY
 0x0002

1053 

	#MT_EDIT
 0x0004

1054 

	#MT_SEARCH
 0x0008

1055 

	#MT_DHISTORY
 0x0010

1056 

	)

1057 
ulÚg
 
	tSPECFUNC
(*,
	tulÚg
,ulÚg,ulÚg,
	tt_di§sm
 *,);

1059 
	st_dump
 {

1060 
t_bË
 
	mbË
;

1061 
	mdimmed
;

1062 
ulÚg
 
	mth»adid
;

1063 
	mdum±y³
;

1064 
SPECFUNC
 *
	m¥ecdump
;

1065 
	mm’uty³
;

1066 
	m™emwidth
;

1067 
	mshow¡ackäames
;

1068 
	mshow¡ackloÿls
;

1069 
	mcomm’tmode
;

1070 
	mfž’ame
[
MAX_PATH
];

1071 
ulÚg
 
	mba£
;

1072 
ulÚg
 
	msize
;

1073 
ulÚg
 
	maddr
;

1074 
ulÚg
 
	mϡaddr
;

1075 
ulÚg
 
	m£l0
;

1076 
ulÚg
 
	m£l1
;

1077 
ulÚg
 
	m¡¬t£l
;

1078 
	mÿ±u»d
;

1079 
ulÚg
 
	m»Ïddr
;

1080 
	m»Êame
[
SHORTLEN
];

1081 
uch¬
 *
	mfžecÝy
;

1082 
uch¬
 *
	mbackup
;

1083 
	mruÁ¿ûoff£t
;

1084 
ulÚg
 
	mȣrved
[8];

1085 } 
	tt_dump
;

1090 

	#WM_USER_MENU
 (
WM_USER
+101)

1091 

	#WM_USER_SCR
 (
WM_USER
+102)

1092 

	#WM_USER_SAVE
 (
WM_USER
+103)

1093 

	#WM_USER_VABS
 (
WM_USER
+104)

1094 

	#WM_USER_VREL
 (
WM_USER
+105)

1095 

	#WM_USER_VBYTE
 (
WM_USER
+106)

1096 

	#WM_USER_STS
 (
WM_USER
+107)

1097 

	#WM_USER_CNTS
 (
WM_USER
+108)

1098 

	#WM_USER_CHGS
 (
WM_USER
+109)

1099 

	#WM_USER_BAR
 (
WM_USER
+110)

1100 

	#WM_USER_DBLCLK
 (
WM_USER
+111)

1101 

	#WM_USER_SIZE
 (
WM_USER
+112)

1102 

	#WM_USER_FOCUS
 (
WM_USER
+113)

1103 

	#WM_USER_FILE
 (
WM_USER
+114)

1104 

	#WM_USER_HERE
 (
WM_USER
+115)

1105 

	#WM_USER_CHALL
 (
WM_USER
+116)

1106 

	#WM_USER_CHMEM
 (
WM_USER
+117)

1107 

	#WM_USER_CHREG
 (
WM_USER
+118)

1108 

	#WM_USER_CHNAM
 (
WM_USER
+119)

1109 

	#WM_USER_MOUSE
 (
WM_USER
+120)

1110 

	#WM_USER_KEY
 (
WM_USER
+121)

1111 

	#WM_USER_SYSKEY
 (
WM_USER
+122)

1112 

	)

1114 

	#MAXTRACK
 16384

1115 

	#MOVETOP
 0x7FFFFFFFL

1116 

	#MOVEBOTTOM
 0x7FFFFFFEL

1117 

	)

1118 

	#CONT_BROADCAST
 0x0000

1119 

	#STOP_BROADCAST
 0x1234

1120 

	)

1122 

	#BKUP_CREATE
 1

1123 

	#BKUP_VIEWDATA
 2

1124 

	#BKUP_VIEWCOPY
 3

1125 

	#BKUP_LOADCOPY
 4

1126 

	#BKUP_SAVEDATA
 5

1127 

	#BKUP_SAVECOPY
 6

1128 

	#BKUP_DELETE
 7

1129 

	)

1130 
extc
 
cdeþ
 
Regi¡”Ùþass
(*
þas¢ame
,

1131 *
icÚÇme
,
WNDPROC
 
þas¥roc
);

1132 
extc
 
HWND
 
cdeþ
 
NewbËwšdow
(
t_bË
 *
±
,
Æšes
,
maxcÞumns
,

1133 *
wšþass
,*
wšt™Ë
);

1134 
extc
 
HWND
 
cdeþ
 
QuickbËwšdow
(
t_bË
 *
±
,
Æšes
,
maxcÞumns
,

1135 *
wšþass
,*
wšt™Ë
);

1136 
extc
 
HWND
 
cdeþ
 
C»©edumpwšdow
(*
Çme
,
ulÚg
 
ba£
,ulÚg 
size
,

1137 
ulÚg
 
addr
,
ty³
,
SPECFUNC
 *
¥ecdump
);

1138 
extc
 
cdeþ
 
S‘dum±y³
(
t_dump
 *
pd
,
dum±y³
);

1139 
extc
 
cdeþ
 
Dumpbackup
(
t_dump
 *
pd
,
aùiÚ
);

1140 
extc
 
cdeþ
 
Brßdÿ¡
(
UINT
 
msg
,
WPARAM
 
wp
,
LPARAM
 
Í
);

1145 
extc
 
ulÚg
 
cdeþ
 
Com´ess
(
uch¬
 *
bufš
,ulÚg 
nbufš
,

1146 
uch¬
 *
bufout
,
ulÚg
 
nbufout
);

1147 
extc
 
ulÚg
 
cdeþ
 
G‘Üigš®d©asize
(*
bufš
,ulÚg 
nbufš
);

1148 
extc
 
ulÚg
 
cdeþ
 
Decom´ess
(
uch¬
 *
bufš
,ulÚg 
nbufš
,

1149 
uch¬
 *
bufout
,
ulÚg
 
nbufout
);

1150 
extc
 
ulÚg
 
cdeþ
 
C®cuÏ‹üc
(
uch¬
 *
cÝy
,ulÚg 
ba£
,ulÚg 
size
,

1151 
t_moduË
 *
pmod
,
ulÚg
 
fixupoff£t
);

1156 
	st_»f
 {

1157 
ulÚg
 
	maddr
;

1158 
ulÚg
 
	msize
;

1159 
ulÚg
 
	mty³
;

1160 
ulÚg
 
	mde¡
;

1161 } 
	tt_»f
;

1163 
extc
 
cdeþ
 
Fšd»ã»nûs
(
ulÚg
 
ba£
,ulÚg 
size
,ulÚg 
addr0
,ulÚg 
addr1
,

1164 
ulÚg
 
Üigš
,
»cur£Újump
,*
t™Ë
);

1165 
extc
 
cdeþ
 
Fšd¡ršgs
(
ulÚg
 
ba£
,ulÚg 
size
,ulÚg 
Üigš
,*
t™Ë
);

1166 
extc
 
cdeþ
 
Fšd®ldÎÿÎs
(
t_dump
 *
pd
,
ulÚg
 
Üigš
,*
t™Ë
);

1167 
extc
 
cdeþ
 
Fšd®lcommªds
(
t_dump
 *
pd
,
t_asmmod–
 *
mod–
,

1168 
ulÚg
 
Üigš
,*
t™Ë
);

1169 
extc
 
cdeþ
 
Fšd®l£qu’ûs
(
t_dump
 *
pd
,
t_extmod–
 
mod–
[
NSEQ
][
NMODELS
],

1170 
ulÚg
 
Üigš
,*
t™Ë
);

1171 
extc
 
ulÚg
 
cdeþ
 
W®k»ã»nû
(
dœ
);

1172 
extc
 
ulÚg
 
cdeþ
 
W®k»ã»nûex
(
dœ
,ulÚg *
size
);

1177 

	#MEMBP_READ
 0x0001

1178 

	#MEMBP_WRITE
 0x0002

1179 

	#MEMBP_SFX
 0x1000

1180 

	)

1182 

	#TR_HIT
 0x01

1183 

	#TR_SET
 0x02

1184 

	#TR_RTSKIP
 0x20

1185 

	#TR_RTRACE
 0x40

1186 

	#TR_TRACE
 0x80

1187 

	)

1188 

	#HB_FREE
 0

1189 

	#HB_CODE
 1

1190 

	#HB_ACCESS
 2

1191 

	#HB_WRITE
 3

1192 

	#HB_IO
 4

1193 

	#HB_ONESHOT
 5

1194 

	#HB_STOPAN
 6

1195 

	#HB_TEMP
 7

1196 

	)

1198 

	#ATR_ADD
 1

1199 

	#ATR_ADDPROC
 2

1200 

	#ATR_RESET
 3

1201 

	#ATR_REMOVE
 4

1202 

	#ATR_REMOVEALL
 5

1203 

	#ATR_RESTORE
 6

1204 

	#ATR_RTRADD
 7

1205 

	#ATR_RTRJUMPS
 8

1206 

	#ATR_RTRENTRY
 9

1207 

	#ATR_RTREMOVE
 10

1208 

	#ATR_RTSKIP
 11

1209 

	)

1215 

	#COND_NOBREAK
 0x01

1216 

	#COND_LOGTRUE
 0x02

1217 

	#COND_LOGALWAYS
 0x04

1218 

	#COND_ARGTRUE
 0x08

1219 

	#COND_ARGALWAYS
 0x10

1220 

	#COND_BRKALWAYS
 0x20

1221 

	#COND_MASK
 0x3F

1222 

	#COND_FILLING
 0x40

1223 

	)

1224 
	st_bpošt
 {

1225 
ulÚg
 
	maddr
;

1226 
ulÚg
 
	mdummy
;

1227 
ulÚg
 
	mty³
;

1228 
	mcmd
;

1229 
ulÚg
 
	m·sscouÁ
;

1230 } 
	tt_bpošt
;

1232 
	st_h¬dbpošt
 {

1233 
ulÚg
 
	maddr
;

1234 
	msize
;

1235 
	mty³
;

1236 
ulÚg
 
	mȣrved
[4];

1237 } 
	tt_h¬dbpošt
;

1239 
extc
 
cdeþ
 
S‘b»akpošt
(
ulÚg
 
addr
,ulÚg 
ty³
,
uch¬
 
cmd
);

1240 
extc
 
cdeþ
 
S‘b»akpoš‹xt
(
ulÚg
 
addr
,ulÚg 
ty³
,
cmd
,

1241 
ulÚg
 
·sscouÁ
);

1242 
extc
 
cdeþ
 
Mªu®b»akpošt
(
ulÚg
 
addr
,

1243 
key
,
shiákey
,
ulÚg
 
Çm‘y³
,
fÚt
);

1244 
extc
 
cdeþ
 
D–‘eb»akpošts
(
ulÚg
 
addr0
,ulÚg 
addr1
,
sž’t
);

1245 
extc
 
ulÚg
 
cdeþ
 
G‘b»akpoš‰y³
(ulÚg 
addr
);

1246 
extc
 
ulÚg
 
cdeþ
 
G‘b»akpoš‰y³couÁ
(ulÚg 
addr
,ulÚg *
·sscouÁ
);

1247 
extc
 
ulÚg
 
cdeþ
 
G‘Ãxtb»akpošt
(ulÚg 
addr
,ulÚg *
ty³
,*
cmd
);

1248 
extc
 
cdeþ
 
Tempb»akpošt
(
ulÚg
 
addr
,
mode
);

1249 
extc
 
cdeþ
 
H¬db»akpošts
(
þo£Úd–‘e
);

1250 
extc
 
cdeþ
 
S‘h¬dw¬eb»akpošt
(
ulÚg
 
addr
,
size
,
ty³
);

1251 
extc
 
cdeþ
 
D–‘eh¬dw¬eb»akpošt
(
šdex
);

1252 
extc
 
cdeþ
 
D–‘eh¬dw¬eb»akbyaddr
(
ulÚg
 
addr
);

1253 
extc
 
cdeþ
 
S‘memb»akpošt
(
ty³
,
ulÚg
 
addr
,ulÚg 
size
);

1254 
extc
 
uch¬
* 
cdeþ
 
Fšdh™Œaû
(
ulÚg
 
addr
,uch¬ **
±¿ûcÝy
,ulÚg *
psize
);

1255 
extc
 
cdeþ
 
Modifyh™Œaû
(
ulÚg
 
addr0
,ulÚg 
addr1
,
mode
);

1256 
extc
 
ulÚg
 
cdeþ
 
I¤‘addr
(ulÚg 
»ddr
,ulÚg *
´oÿddr
);

1257 
extc
 
HWND
 
cdeþ
 
C»©”Œaûwšdow
();

1258 
extc
 
cdeþ
 
S‘ŒaûcÚd™iÚ
(*
cÚd
,
Úsu¥icious
,

1259 
ulÚg
 
š0
,ulÚg 
š1
,ulÚg 
out0
,ulÚg 
out1
);

1260 
extc
 
cdeþ
 
S‘ŒaûcouÁ
(
ulÚg
 
couÁ
);

1261 
extc
 
cdeþ
 
S‘Œaû·u£Úcommªds
(*
cmd£t
);

1262 
extc
 
cdeþ
 
S¹ruÁ¿û
(
t_»g
 *
´eg
);

1263 
extc
 
cdeþ
 
D–‘”uÁ¿û
();

1264 
extc
 
cdeþ
 
RuÁ¿ûsize
();

1265 
extc
 
cdeþ
 
Fšd´evruÁ¿û
(
ulÚg
 

,
¡¬tback
);

1266 
extc
 
cdeþ
 
FšdÃxŒuÁ¿û
(
ulÚg
 

,
¡¬tback
);

1267 
extc
 
cdeþ
 
G‘ruÁ¿û»gi¡”s
(
nback
,
t_»g
 *
´eg
,

1268 
t_»g
 *
pÞd
,*
cmd
,*
comm’t
);

1269 
extc
 
cdeþ
 
G‘ruÁ¿û´ofže
(
ulÚg
 
addr
,ulÚg 
size
,ulÚg *
´ofže
);

1270 
extc
 
cdeþ
 
SüÞÌuÁ¿ûwšdow
(
back
);

1271 
extc
 
HWND
 
cdeþ
 
C»©•rofžewšdow
(
ulÚg
 
ba£
,ulÚg 
size
);

1277 
	tINJECTANSWER
(*
	td©a
,
	tulÚg
 
	td©asize
,ulÚg 
	t·rm2
);

1279 
	st_šjeù
 {

1280 
ulÚg
 
	mcodesize
;

1281 *
	mcode
;

1282 
	m¡acksize
;

1283 
	md©©y³
;

1284 } 
	tt_šjeù
;

1286 
extc
 
cdeþ
 
Injeùcode
(
ulÚg
 
th»adid
,
t_šjeù
 *
šjeù
,*
d©a
,

1287 
ulÚg
 
d©asize
,ulÚg 
·rm1
,ulÚg 
·rm2
,

1288 
INJECTANSWER
 *
ªsw”func
);

1295 

	#CPU_ASMHIST
 0x00001

1296 

	#CPU_ASMCENTER
 0x00004

1297 

	#CPU_ASMFOCUS
 0x00008

1298 

	#CPU_DUMPHIST
 0x00010

1299 

	#CPU_DUMPFIRST
 0x00020

1300 

	#CPU_DUMPFOCUS
 0x00080

1301 

	#CPU_REGAUTO
 0x00100

1302 

	#CPU_RUNTRACE
 0x00200

1303 

	#CPU_STACKFOCUS
 0x00800

1304 

	#CPU_NOCREATE
 0x04000

1305 

	#CPU_REDRAW
 0x08000

1306 

	#CPU_NOFOCUS
 0x10000

1307 

	)

1308 
extc
 
cdeþ
 
S‘ýu
(
ulÚg
 
th»adid
,ulÚg 
asmaddr
,

1309 
ulÚg
 
dum·ddr
,ulÚg 
¡ackaddr
,
mode
);

1310 
extc
 
cdeþ
 
S‘di§sm
(
ulÚg
 
asmaddr
,ulÚg 
£lsize
,
mode
);

1311 
extc
 
cdeþ
 
Red¿wdi§s£mbËr
();

1312 
extc
 
cdeþ
 
G‘di§s£mb˼ªge
(
ulÚg
 *
pba£
,ulÚg *
psize
);

1313 
extc
 
ulÚg
 
cdeþ
 
Fšd´ocbegš
(ulÚg 
addr
);

1314 
extc
 
ulÚg
 
cdeþ
 
Fšd´oûnd
(ulÚg 
addr
);

1315 
extc
 
ulÚg
 
cdeþ
 
Fšd´ev´oc
(ulÚg 
addr
);

1316 
extc
 
ulÚg
 
cdeþ
 
FšdÃxroc
(ulÚg 
addr
);

1317 
extc
 
cdeþ
 
G‘´oþim™s
(
ulÚg
 
addr
,ulÚg *
¡¬t
,ulÚg *
’d
);

1318 
extc
 
cdeþ
 
S’dshÜtcut
(
wh”e
,
ulÚg
 
addr
,

1319 
msg
,
ù¾
,
shiá
,
vkcode
);

1325 

	#STEP_SAME
 0

1326 

	#STEP_RUN
 1

1327 

	#STEP_OVER
 2

1328 

	#STEP_IN
 3

1329 

	#STEP_SKIP
 4

1330 

	)

1331 
	et_¡©us
 {

1332 
	mSTAT_NONE
=0,

1333 
	mSTAT_STOPPED
,

1334 
	mSTAT_EVENT
,

1335 
	mSTAT_RUNNING
,

1336 
	mSTAT_FINISHED
,

1337 
	mSTAT_CLOSING


1338 } 
	tt_¡©us
;

1340 
extc
 
t_¡©us
 
cdeþ
 
G‘¡©us
();

1341 
extc
 
cdeþ
 
Go
(
ulÚg
 
th»adid
,ulÚg 
tžÏddr
,
¡•mode
,

1342 
givechªû
,
backu´egs
);

1343 
extc
 
cdeþ
 
Su¥’d´oûss
(
´oûs£v’ts
);

1348 

	#DASC_TEST
 0

1349 

	#DASC_NOHEX
 1

1350 

	#DASC_ASCII
 2

1351 

	#DASC_PASCAL
 3

1352 

	)

1353 
extc
 
uch¬
* 
cdeþ
 
FšdknownfunùiÚ
(
ulÚg
 
addr
,
dœeù
,

1354 
Ëv–
,*
âame
);

1355 
extc
 
cdeþ
 
DecodeknowÇrgum’t
(
ulÚg
 
addr
,
uch¬
 *
¬g
,ulÚg 
v®ue
,

1356 
v®id
,*
s
,*
mask
,
uch¬
 *
p£t
[]);

1357 
extc
 
cdeþ
 *
FšdunknownfunùiÚ
(
ulÚg
 

,*
code
,*
dec
,

1358 
ulÚg
 
size
,*
âame
);

1359 
extc
 
cdeþ
 
Decod—scii
(
ulÚg
 
v®ue
,*
s
,
Ën
,
mode
);

1360 
extc
 
cdeþ
 
Decodeunicode
(
ulÚg
 
v®ue
,*
s
,
Ën
);

1365 

	#FIRST_CODE_LINE
 0xFFFFFFFF

1366 

	)

1367 
	st_sourûlše
 {

1368 
ulÚg
 
	maddr
;

1369 
ulÚg
 
	msize
;

1370 
ulÚg
 
	m¤úame
;

1371 
ulÚg
 
	mlše
;

1372 } 
	tt_sourûlše
;

1374 
extc
 
HWND
 
cdeþ
 
Showsourûäomadd»ss
(
ulÚg
 
addr
,
show
);

1375 
extc
 
cdeþ
 
G‘»sourû¡ršg
(
t_moduË
 *
pm
,
ulÚg
 
id
,*
s
);

1376 
extc
 
t_sourûlše
* 
cdeþ
 
G‘lšeäomadd»ss
(
ulÚg
 
addr
);

1377 
extc
 
ulÚg
 
cdeþ
 
G‘add»ssäomlše
(ulÚg 
addr0
,ulÚg 
addr1
,

1378 *
·th
,
ulÚg
 
lše
);

1379 
extc
 
cdeþ
 
G‘sourûfž–im™s
(
ulÚg
 
Çm—ddr
,

1380 
ulÚg
 *
addr0
,ulÚg *
addr1
);

1381 
extc
 
cdeþ
 
DecodefuÎv¬Çme
(
t_moduË
 *
pmod
,
t_symv¬
 *
psym
,

1382 
off£t
,*
Çme
);

1383 
extc
 
cdeþ
 
G‘b´–Çme
(
t_moduË
 *
pmod
,
ulÚg
 
addr
,
off£t
,

1384 *
s
,
nsymb
);

1389 
extc
 
HWND
 
cdeþ
 
C»©ew©chwšdow
();

1390 
extc
 
cdeþ
 
D–‘ew©ch
(
šdexÚe
);

1391 
extc
 
cdeþ
 
In£¹w©ch
(
šdexÚe
,*
‹xt
);

1392 
extc
 
cdeþ
 
G‘w©ch
(
šdexÚe
,*
‹xt
);

1397 

	#MAXNEST
 32

1398 

	)

1399 
	st_wšdow
 {

1400 
ulÚg
 
	mhwnd
;

1401 
ulÚg
 
	mdummy
;

1402 
ulÚg
 
	mty³
;

1403 
ulÚg
 
	m·»Áhw
;

1404 
ulÚg
 
	mwš´oc
;

1405 
ulÚg
 
	mth»adid
;

1406 
ulÚg
 
	mex¡yË
;

1407 
ulÚg
 
	m¡yË
;

1408 
ulÚg
 
	mid
;

1409 
ulÚg
 
	mþas¥roc
;

1410 
	mchžd
;

1411 
	mËv–
;

1412 
	msiblšg
;

1413 
	mby·»Á
;

1414 
	mt™Ë
[
TEXTLEN
];

1415 
	mþas¢ame
[
TEXTLEN
];

1416 
	mŒ“
[
MAXNEST
];

1417 } 
	tt_wšdow
;

1419 
extc
 
HWND
 
cdeþ
 
C»©ewšwšdow
();

1425 
	st_·tch
 {

1426 
ulÚg
 
	maddr
;

1427 
ulÚg
 
	msize
;

1428 
ulÚg
 
	mty³
;

1429 
	mÜig
[
TEXTLEN
];

1430 
	mmod
[
TEXTLEN
];

1431 } 
	tt_·tch
;

1433 
extc
 
HWND
 
cdeþ
 
C»©•©chwšdow
();

1440 

	#VAL_HINST
 1

1441 

	#VAL_HWMAIN
 2

1442 

	#VAL_HWCLIENT
 3

1443 

	#VAL_NCOLORS
 4

1444 

	#VAL_COLORS
 5

1445 

	#VAL_BRUSHES
 6

1446 

	#VAL_PENS
 7

1447 

	#VAL_NFONTS
 8

1448 

	#VAL_FONTS
 9

1449 

	#VAL_FONTNAMES
 10

1450 

	#VAL_FONTWIDTHS
 11

1451 

	#VAL_FONTHEIGHTS
 12

1452 

	#VAL_NFIXFONTS
 13

1453 

	#VAL_DEFFONT
 14

1454 

	#VAL_NSCHEMES
 15

1455 

	#VAL_SCHEMES
 16

1456 

	#VAL_DEFSCHEME
 17

1457 

	#VAL_DEFHSCROLL
 18

1458 

	#VAL_RESTOREWINDOWPOS
 19

1459 

	#VAL_HPROCESS
 20

1460 

	#VAL_PROCESSID
 21

1461 

	#VAL_HMAINTHREAD
 22

1462 

	#VAL_MAINTHREADID
 23

1463 

	#VAL_MAINBASE
 24

1464 

	#VAL_PROCESSNAME
 25

1465 

	#VAL_EXEFILENAME
 26

1466 

	#VAL_CURRENTDIR
 27

1467 

	#VAL_SYSTEMDIR
 28

1468 

	#VAL_DECODEANYIP
 29

1469 

	#VAL_PASCALSTRINGS
 30

1470 

	#VAL_ONLYASCII
 31

1471 

	#VAL_DIACRITICALS
 32

1472 

	#VAL_GLOBALSEARCH
 33

1473 

	#VAL_ALIGNEDSEARCH
 34

1474 

	#VAL_IGNORECASE
 35

1475 

	#VAL_SEARCHMARGIN
 36

1476 

	#VAL_KEEPSELSIZE
 37

1477 

	#VAL_MMXDISPLAY
 38

1478 

	#VAL_WINDOWFONT
 39

1479 

	#VAL_TABSTOPS
 40

1480 

	#VAL_MODULES
 41

1481 

	#VAL_MEMORY
 42

1482 

	#VAL_THREADS
 43

1483 

	#VAL_BREAKPOINTS
 44

1484 

	#VAL_REFERENCES
 45

1485 

	#VAL_SOURCELIST
 46

1486 

	#VAL_WATCHES
 47

1487 

	#VAL_CPUFEATURES
 50

1488 

	#VAL_TRACEFILE
 51

1489 

	#VAL_ALIGNDIALOGS
 52

1490 

	#VAL_CPUDASM
 53

1491 

	#VAL_CPUDDUMP
 54

1492 

	#VAL_CPUDSTACK
 55

1493 

	#VAL_APIHELP
 56

1494 

	#VAL_HARDBP
 57

1495 

	#VAL_PATCHES
 58

1496 

	#VAL_HINTS
 59

1497 

	)

1498 
extc
 
cdeþ
 
Regi¡”¶ugšþass
(*
þas¢ame
,*
icÚÇme
,

1499 
HINSTANCE
 
dΚ¡
,
WNDPROC
 
þas¥roc
);

1500 
extc
 
cdeþ
 
UÄegi¡”¶ugšþass
(*
þas¢ame
);

1501 
extc
 
cdeþ
 
Plugšwr™eš‰oši
(
HINSTANCE
 
dΚ¡
,*
key
,
v®ue
);

1502 
extc
 
cdeþ
 
Plugšwr™e¡ršgtoši
(
HINSTANCE
 
dΚ¡
,*
key
,*
s
);

1503 
extc
 
cdeþ
 
Plugš»adštäomši
(
HINSTANCE
 
dΚ¡
,*
key
,
def
);

1504 
extc
 
cdeþ
 
Plugš»ad¡ršgäomši
(
HINSTANCE
 
dΚ¡
,*
key
,

1505 *
s
,*
def
);

1506 
extc
 
cdeþ
 
Plugš§v”ecÜd
(
ulÚg
 
g
,ulÚg 
size
,*
d©a
);

1507 
extc
 
cdeþ
 
Plugšg‘v®ue
(
ty³
);

1515 

	#PM_MAIN
 0

1516 

	#PM_DUMP
 10

1517 

	#PM_MODULES
 11

1518 

	#PM_MEMORY
 12

1519 

	#PM_THREADS
 13

1520 

	#PM_BREAKPOINTS
 14

1521 

	#PM_REFERENCES
 15

1522 

	#PM_RTRACE
 16

1523 

	#PM_WATCHES
 17

1524 

	#PM_WINDOWS
 18

1525 

	#PM_DISASM
 31

1526 

	#PM_CPUDUMP
 32

1527 

	#PM_CPUSTACK
 33

1528 

	#PM_CPUREGS
 34

1529 

	)

1532 

	#PP_MAIN
 0x0003

1533 

	#PP_EVENT
 0x0000

1534 

	#PP_PAUSE
 0x0001

1535 

	#PP_TERMINATED
 0x0002

1537 

	#PP_BYPROGRAM
 0x0004

1538 

	#PP_INT3BREAK
 0x0010

1539 

	#PP_MEMBREAK
 0x0020

1540 

	#PP_HWBREAK
 0x0040

1541 

	#PP_SINGLESTEP
 0x0080

1542 

	#PP_EXCEPTION
 0x0100

1543 

	#PP_ACCESS
 0x0200

1544 

	#PP_GUARDED
 0x0400

1545 

	)

1547 

	#MI_SIGNATURE
 0x00646F4DL

1548 

	#MI_VERSION
 0x7265560AL

1549 

	#MI_FILENAME
 0x6C69460AL

1550 

	#MI_FILESIZE
 0x7A69530AL

1551 

	#MI_TIMESTAMP
 0x7473540AL

1552 

	#MI_SFXENTRY
 0x6566530AL

1553 

	#MI_PATCH
 0x7461500AL

1554 

	#MI_USER
 0x0073550AL

1555 

	#MI_PROCDATA
 0x6372500AL

1556 

	#MI_SWDATA
 0x6977530AL

1557 

	#MI_CALLFINT
 0x6966430AL

1558 

	#MI_CALLFMOD
 0x6D66430AL

1559 

	#MI_CALLFABS
 0x6166430AL

1560 

	#MI_INT3BREAK
 0x7470420AL

1561 

	#MI_INT3BRKC
 0x6370420AL

1562 

	#MI_HDWRBREAK
 0x7262480AL

1563 

	#MI_JDDATA
 0x74644A0AL

1564 

	#MI_ANALYSIS
 0x616E410AL

1565 

	#MI_ANALPACK
 0x636E410AL

1566 

	#MI_AHINT
 0x7468410AL

1567 

	#MI_TRACE
 0x6172540AL

1568 

	#MI_TRACEPACK
 0x6372540AL

1569 

	#MI_CODECRC
 0x7263430AL

1570 

	#MI_SAVEAREA
 0x6176530AL

1571 

	#MI_END
 0x646E450AL

1573 

	#MI_WINJUG
 0x67754A0AL

1574 

	#MI_WINJU1
 0x31754A0AL

	)

1575 

	#MI_WINJU2
 0x32754A0AL

	)

1576 

	#MI_WINJU3
 0x33754A0AL

	)

1577 

	#MI_APPST
 0x73614F0AL

1578 

	)

1580 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšd©a
(
shÜŠame
[32]);

1581 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšš™
(
Þlydbgv”siÚ
,
HWND
 
hw
,

1582 
ulÚg
 *
ã©u»s
);

1583 
extc
 
_expÜt
 
cdeþ
 
ODBG_PlugšmašloÝ
(
DEBUG_EVENT
 *
debugev’t
);

1584 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugš§veudd
(
t_moduË
 *
pmod
,
ismašmoduË
);

1585 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšudd»cÜd
(
t_moduË
 *
pmod
,
ismašmoduË
,

1586 
ulÚg
 
g
,ulÚg 
size
,*
d©a
);

1587 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšm’u
(
Üigš
,
d©a
[4096],*
™em
);

1588 
extc
 
_expÜt
 
cdeþ
 
ODBG_PlugšaùiÚ
(
Üigš
,
aùiÚ
,*
™em
);

1589 
extc
 
_expÜt
 
cdeþ
 
ODBG_PlugšshÜtcut
(

1590 
Üigš
,
ù¾
,
®t
,
shiá
,
key
,

1591 *
™em
);

1592 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugš»£t
();

1593 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšþo£
();

1594 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšde¡roy
();

1595 
extc
 
_expÜt
 
cdeþ
 
ODBG_Pau£d
(
»asÚ
,
t_»g
 *
»g
);

1596 
extc
 
_expÜt
 
cdeþ
 
ODBG_Pau£dex
(
»asÚex
,
dummy
,
t_»g
 *
»g
,

1597 
DEBUG_EVENT
 *
debugev’t
);

1598 
extc
 
_expÜt
 
cdeþ
 
ODBG_Plugšcmd
(
»asÚ
,
t_»g
 *
»g
,*
cmd
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\stdafx.cpp

5 
	~"¡dafx.h
"

	@E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\stdafx.h

6 #´agm¨
Úû


8 

	#_WINSOCKAPI_


	)

9 

	#WIN32_LEAN_AND_MEAN


11 
	~<wšdows.h
>

	)

12 
	~<wšsock2.h
>

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_bsd.c

10 
	~<PythÚ.h
>

11 
	~<as£¹.h
>

12 
	~<Ӽo.h
>

13 
	~<¡dlib.h
>

14 
	~<¡dio.h
>

15 
	~<sigÇl.h
>

16 
	~<fúŽ.h
>

17 
	~<·ths.h
>

18 
	~<sys/ty³s.h
>

19 
	~<sys/sysùl.h
>

20 
	~<sys/·¿m.h
>

21 
	~<sys/u£r.h
>

22 
	~<sys/´oc.h
>

23 
	~<sys/fže.h
>

24 
	~<Ãt/rou‹.h
>

26 
	~<sys/sock‘.h
>

27 
	~<sys/sock‘v¬.h
>

28 
	~<sys/un.h
>

29 
	~<sys/uÅcb.h
>

31 
	~<Ãtš‘/š.h
>

32 
	~<Ãtš‘/š_sy¡m.h
>

33 
	~<Ãtš‘/.h
>

34 
	~<Ãtš‘/š_pcb.h
>

35 
	~<Ãtš‘/tý_v¬.h
>

36 
	~<Ãtš‘/tý_fsm.h
>

37 
	~<¬·/š‘.h
>

39 #ià
__F»eBSD_v”siÚ
 < 900000

40 
	~<utmp.h
>

42 
	~<utmpx.h
>

44 
	~<dev¡©.h
>

45 
	~<sys/vmm‘”.h
>

46 
	~<libutž.h
>

47 
	~<sys/mouÁ.h
>

49 
	~<Ãt/if.h
>

50 
	~<Ãt/if_dl.h
>

51 
	~<Ãt/rou‹.h
>

53 
	~<Ãtš‘/š.h
>

54 
	~<sys/un.h
>

56 
	~"_psutž_bsd.h
"

57 
	~"_psutž_commÚ.h
"

58 
	~"¬ch/bsd/´oûss_šfo.h
"

62 

	#TV2DOUBLE
(
t
è(Ñ).
tv_£c
 + (t).
tv_u£c
 / 1000000.0)

	)

69 
	$psutž_kšfo_´oc
(cÚ¡ 
pid_t
 
pid
, 
kšfo_´oc
 *
´oc
)

71 
mib
[4];

72 
size_t
 
size
;

73 
mib
[0] = 
CTL_KERN
;

74 
mib
[1] = 
KERN_PROC
;

75 
mib
[2] = 
KERN_PROC_PID
;

76 
mib
[3] = 
pid
;

78 
size
 = (
kšfo_´oc
);

80 ià(
	`sysùl
((*)
mib
, 4, 
´oc
, &
size
, 
NULL
, 0) == -1) {

81 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

86 ià(
size
 == 0) {

87 
	`NoSuchProûss
();

91 
	}
}

97 
PyObjeù
 *

98 
	$psutž_pids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

100 
kšfo_´oc
 *
´oþi¡
 = 
NULL
;

101 
kšfo_´oc
 *
Üig_add»ss
 = 
NULL
;

102 
size_t
 
num_´oûs£s
;

103 
size_t
 
idx
;

104 
PyObjeù
 *
»Ži¡
 = 
	`PyLi¡_New
(0);

105 
PyObjeù
 *
pid
 = 
NULL
;

107 ià(
»Ži¡
 =ð
NULL
) {

108  
NULL
;

110 ià(
	`psutž_g‘_´oc_li¡
(&
´oþi¡
, &
num_´oûs£s
) != 0) {

111 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

113 
”rÜ
;

116 ià(
num_´oûs£s
 > 0) {

117 
Üig_add»ss
 = 
´oþi¡
;

118 
idx
 = 0; idx < 
num_´oûs£s
; idx++) {

119 
pid
 = 
	`Py_BuždV®ue
("i", 
´oþi¡
->
ki_pid
);

120 ià(!
pid
)

121 
”rÜ
;

122 ià(
	`PyLi¡_Aµ’d
(
»Ži¡
, 
pid
))

123 
”rÜ
;

124 
	`Py_DECREF
(
pid
);

125 
´oþi¡
++;

127 
	`ä“
(
Üig_add»ss
);

130  
»Ži¡
;

132 
”rÜ
:

133 
	`Py_XDECREF
(
pid
);

134 
	`Py_DECREF
(
»Ži¡
);

135 ià(
Üig_add»ss
 !ð
NULL
) {

136 
	`ä“
(
Üig_add»ss
);

138  
NULL
;

139 
	}
}

146 
PyObjeù
 *

147 
	$psutž_boÙ_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

150 
»que¡
[2] = { 
CTL_KERN
, 
KERN_BOOTTIME
 };

151 
timev®
 
boÙtime
;

152 
size_t
 
Ën
 = (
boÙtime
);

154 ià(
	`sysùl
(
»que¡
, 2, &
boÙtime
, &
Ën
, 
NULL
, 0) == -1) {

155 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

156  
NULL
;

158  
	`Py_BuždV®ue
("d", ()
boÙtime
.
tv_£c
);

159 
	}
}

165 
PyObjeù
 *

166 
	$psutž_´oc_Çme
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

168 
pid
;

169 
kšfo_´oc
 
kp
;

170 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

171  
NULL
;

173 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

174  
NULL
;

176  
	`Py_BuždV®ue
("s", 
kp
.
ki_comm
);

177 
	}
}

185 
PyObjeù
 *

186 
	$psutž_´oc_exe
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

188 
pid
;

189 
·thÇme
[
PATH_MAX
];

190 
”rÜ
;

191 
mib
[4];

192 
size_t
 
size
;

194 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

195  
NULL
;

198 
mib
[0] = 
CTL_KERN
;

199 
mib
[1] = 
KERN_PROC
;

200 
mib
[2] = 
KERN_PROC_PATHNAME
;

201 
mib
[3] = 
pid
;

203 
size
 = (
·thÇme
);

204 
”rÜ
 = 
	`sysùl
(
mib
, 4, 
·thÇme
, &
size
, 
NULL
, 0);

205 ià(
”rÜ
 == -1) {

206 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

207  
NULL
;

209 ià(
size
 =ð0 || 
	`¡¾’
(
·thÇme
) == 0) {

210 ià(
	`psutž_pid_exi¡s
(
pid
) == 0) {

211  
	`NoSuchProûss
();

214 
	`¡rýy
(
·thÇme
, "");

217  
	`Py_BuždV®ue
("s", 
·thÇme
);

218 
	}
}

224 
PyObjeù
 *

225 
	$psutž_´oc_cmdlše
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

227 
pid
;

228 
PyObjeù
 *
¬gli¡
 = 
NULL
;

230 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

231  
NULL
;

235 
¬gli¡
 = 
	`psutž_g‘_¬g_li¡
(
pid
);

239 ià(
NULL
 =ð
¬gli¡
) {

240  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

242  
	`Py_BuždV®ue
("N", 
¬gli¡
);

243 
	}
}

249 
PyObjeù
 *

250 
	$psutž_´oc_µid
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

252 
pid
;

253 
kšfo_´oc
 
kp
;

254 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

255  
NULL
;

257 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

258  
NULL
;

260  
	`Py_BuždV®ue
("l", ()
kp
.
ki_µid
);

261 
	}
}

267 
PyObjeù
 *

268 
	$psutž_´oc_¡©us
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

270 
pid
;

271 
kšfo_´oc
 
kp
;

272 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

273  
NULL
;

275 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

276  
NULL
;

278  
	`Py_BuždV®ue
("i", ()
kp
.
ki_¡©
);

279 
	}
}

286 
PyObjeù
 *

287 
	$psutž_´oc_uids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

289 
pid
;

290 
kšfo_´oc
 
kp
;

291 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

292  
NULL
;

294 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

295  
NULL
;

297  
	`Py_BuždV®ue
("lll",

298 ()
kp
.
ki_ruid
,

299 ()
kp
.
ki_uid
,

300 ()
kp
.
ki_svuid
);

301 
	}
}

308 
PyObjeù
 *

309 
	$psutž_´oc_gids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

311 
pid
;

312 
kšfo_´oc
 
kp
;

313 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

314  
NULL
;

316 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

317  
NULL
;

319  
	`Py_BuždV®ue
("lll",

320 ()
kp
.
ki_rgid
,

321 ()
kp
.
ki_groups
[0],

322 ()
kp
.
ki_svuid
);

323 
	}
}

330 
PyObjeù
 *

331 
	$psutž_´oc_‰y_Ä
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

333 
pid
;

334 
kšfo_´oc
 
kp
;

335 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

336  
NULL
;

338 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

339  
NULL
;

341  
	`Py_BuždV®ue
("i", 
kp
.
ki_tdev
);

342 
	}
}

348 
PyObjeù
 *

349 
	$psutž_´oc_num_ùx_sw™ches
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

351 
pid
;

352 
kšfo_´oc
 
kp
;

353 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

354  
NULL
;

356 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

357  
NULL
;

359  
	`Py_BuždV®ue
("(ll)",

360 
kp
.
ki_ru§ge
.
ru_nvcsw
,

361 
kp
.
ki_ru§ge
.
ru_nivcsw
);

362 
	}
}

368 
PyObjeù
 *

369 
	$psutž_´oc_num_th»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

371 
pid
;

372 
kšfo_´oc
 
kp
;

373 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

374  
NULL
;

376 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

377  
NULL
;

379  
	`Py_BuždV®ue
("l", ()
kp
.
ki_numth»ads
);

380 
	}
}

390 
PyObjeù
 *

391 
	$psutž_´oc_th»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

393 
pid
;

394 
mib
[4];

395 
kšfo_´oc
 *
k
 = 
NULL
;

396 
kšfo_´oc
 *
kp
 = 
NULL
;

397 
”rÜ
;

398 
i
;

399 
size_t
 
size
;

400 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

401 
PyObjeù
 *
pyTu¶e
 = 
NULL
;

403 ià(
»tLi¡
 =ð
NULL
)

404  
NULL
;

405 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
))

406 
”rÜ
;

409 
mib
[0] = 
CTL_KERN
;

410 
mib
[1] = 
KERN_PROC
;

411 
mib
[2] = 
KERN_PROC_PID
 | 
KERN_PROC_INC_THREAD
;

412 
mib
[3] = 
pid
;

414 
size
 = 0;

415 
”rÜ
 = 
	`sysùl
(
mib
, 4, 
NULL
, &
size
, NULL, 0);

416 ià(
”rÜ
 == -1) {

417 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

418 
”rÜ
;

420 ià(
size
 == 0) {

421 
	`NoSuchProûss
();

422 
”rÜ
;

425 
k
 = 
	`m®loc
(
size
);

426 ià(
k
 =ð
NULL
) {

427 
	`PyE¼_NoMemÜy
();

428 
”rÜ
;

431 
”rÜ
 = 
	`sysùl
(
mib
, 4, 
k
, &
size
, 
NULL
, 0);

432 ià(
”rÜ
 == -1) {

433 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

434 
”rÜ
;

436 ià(
size
 == 0) {

437 
	`NoSuchProûss
();

438 
”rÜ
;

441 
i
 = 0; i < 
size
 / (*
kp
); i++) {

442 
kp
 = &
k
[
i
];

443 
pyTu¶e
 = 
	`Py_BuždV®ue
("Idd",

444 
kp
->
ki_tid
,

445 
	`TV2DOUBLE
(
kp
->
ki_ru§ge
.
ru_utime
),

446 
	`TV2DOUBLE
(
kp
->
ki_ru§ge
.
ru_¡ime
));

447 ià(
pyTu¶e
 =ð
NULL
)

448 
”rÜ
;

449 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
pyTu¶e
))

450 
”rÜ
;

451 
	`Py_DECREF
(
pyTu¶e
);

453 
	`ä“
(
k
);

454  
»tLi¡
;

456 
”rÜ
:

457 
	`Py_XDECREF
(
pyTu¶e
);

458 
	`Py_DECREF
(
»tLi¡
);

459 ià(
k
 !ð
NULL
) {

460 
	`ä“
(
k
);

462  
NULL
;

463 
	}
}

469 
PyObjeù
 *

470 
	$psutž_´oc_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

472 
pid
;

473 
u£r_t
, 
sys_t
;

474 
kšfo_´oc
 
kp
;

475 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

476  
NULL
;

478 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

479  
NULL
;

482 
u£r_t
 = 
	`TV2DOUBLE
(
kp
.
ki_ru§ge
.
ru_utime
);

483 
sys_t
 = 
	`TV2DOUBLE
(
kp
.
ki_ru§ge
.
ru_¡ime
);

484  
	`Py_BuždV®ue
("(dd)", 
u£r_t
, 
sys_t
);

485 
	}
}

492 
PyObjeù
 *

493 
	$psutž_ýu_couÁ_logiÿl
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

495 
mib
[2];

496 
nýu
;

497 
size_t
 
Ën
;

499 
mib
[0] = 
CTL_HW
;

500 
mib
[1] = 
HW_NCPU
;

501 
Ën
 = (
nýu
);

503 ià(
	`sysùl
(
mib
, 2, &
nýu
, &
Ën
, 
NULL
, 0) == -1) {

505 
	`Py_INCREF
(
Py_NÚe
);

506  
Py_NÚe
;

509  
	`Py_BuždV®ue
("i", 
nýu
);

511 
	}
}

518 
PyObjeù
 *

519 
	$psutž_ýu_couÁ_phys
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

521 *
tÝÞogy
 = 
NULL
;

522 
size_t
 
size
 = 0;

524 ià(
	`sysùlbyÇme
("k”n.sched.tÝÞogy_¥ec", 
NULL
, &
size
, NULL, 0))

525 
”rÜ
;

527 
tÝÞogy
 = 
	`m®loc
(
size
);

528 ià(!
tÝÞogy
) {

529 
	`PyE¼_NoMemÜy
();

530  
NULL
;

533 ià(
	`sysùlbyÇme
("k”n.sched.tÝÞogy_¥ec", 
tÝÞogy
, &
size
, 
NULL
, 0))

534 
”rÜ
;

536  
	`Py_BuždV®ue
("s", 
tÝÞogy
);

538 
”rÜ
:

539 
	`Py_INCREF
(
Py_NÚe
);

540  
Py_NÚe
;

541 
	}
}

548 
PyObjeù
 *

549 
	$psutž_´oc_ü—‹_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

551 
pid
;

552 
kšfo_´oc
 
kp
;

553 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

554  
NULL
;

556 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

557  
NULL
;

559  
	`Py_BuždV®ue
("d", 
	`TV2DOUBLE
(
kp
.
ki_¡¬t
));

560 
	}
}

567 
PyObjeù
 *

568 
	$psutž_´oc_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

570 
pid
;

571 
kšfo_´oc
 
kp
;

572 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

573  
NULL
;

575 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

576  
NULL
;

579  
	`Py_BuždV®ue
("(llll)",

580 
kp
.
ki_ru§ge
.
ru_šblock
,

581 
kp
.
ki_ru§ge
.
ru_oublock
,

584 
	}
}

590 
PyObjeù
 *

591 
	$psutž_´oc_memÜy_šfo
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

593 
pid
;

594 
kšfo_´oc
 
kp
;

595 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

596  
NULL
;

598 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

599  
NULL
;

601  
	`Py_BuždV®ue
("(lllll)",

602 
	`±ß
(
kp
.
ki_rssize
),

603 ()
kp
.
ki_size
,

604 
	`±ß
(
kp
.
ki_tsize
),

605 
	`±ß
(
kp
.
ki_dsize
),

606 
	`±ß
(
kp
.
ki_ssize
));

607 
	}
}

613 
PyObjeù
 *

614 
	$psutž_vœtu®_mem
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

616 
tÙ®
, 
aùive
, 
šaùive
, 
wœed
, 
ÿched
, 
ä“
;

617 
size_t
 
size
 = (
tÙ®
);

618 
vmtÙ®
 
vm
;

619 
mib
[] = {
CTL_VM
, 
VM_METER
};

620 
·gesize
 = 
	`g‘·gesize
();

621 #ià
__F»eBSD_v”siÚ
 > 702101

622 
bufãrs
;

624 
bufãrs
;

626 
size_t
 
bufãrs_size
 = (
bufãrs
);

628 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_·ge_couÁ", &
tÙ®
, &
size
, 
NULL
, 0))

629 
”rÜ
;

630 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_aùive_couÁ", &
aùive
, &
size
, 
NULL
, 0))

631 
”rÜ
;

632 ià(
	`sysùlbyÇme
("vm.stats.vm.v_inactive_count",

633 &
šaùive
, &
size
, 
NULL
, 0))

634 
”rÜ
;

635 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_wœe_couÁ", &
wœed
, &
size
, 
NULL
, 0))

636 
”rÜ
;

637 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_ÿche_couÁ", &
ÿched
, &
size
, 
NULL
, 0))

638 
”rÜ
;

639 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_ä“_couÁ", &
ä“
, &
size
, 
NULL
, 0))

640 
”rÜ
;

641 ià(
	`sysùlbyÇme
("vfs.buf¥aû", &
bufãrs
, &
bufãrs_size
, 
NULL
, 0))

642 
”rÜ
;

644 
size
 = (
vm
);

645 ià(
	`sysùl
(
mib
, 2, &
vm
, &
size
, 
NULL
, 0) != 0)

646 
”rÜ
;

648  
	`Py_BuždV®ue
("KKKKKKKK",

649 (è
tÙ®
 * 
·gesize
,

650 (è
ä“
 * 
·gesize
,

651 (è
aùive
 * 
·gesize
,

652 (è
šaùive
 * 
·gesize
,

653 (è
wœed
 * 
·gesize
,

654 (è
ÿched
 * 
·gesize
,

655 (è
bufãrs
,

656 (è(
vm
.
t_vmshr
 + vm.
t_rmshr
è* 
·gesize


659 
”rÜ
:

660 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

661  
NULL
;

662 
	}
}

665 #iâdeà
_PATH_DEVNULL


666 

	#_PATH_DEVNULL
 "/dev/nuÎ"

	)

672 
PyObjeù
 *

673 
	$psutž_sw­_mem
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

675 
kvm_t
 *
kd
;

676 
kvm_sw­
 
kvmsw
[1];

677 
sw­š
, 
sw­out
, 
nodeš
, 
nodeout
;

678 
size_t
 
size
 = ();

680 
kd
 = 
	`kvm_Ý’
(
NULL
, 
_PATH_DEVNULL
, NULL, 
O_RDONLY
, "kvm_open failed");

681 ià(
kd
 =ð
NULL
) {

682 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "kvm_open failed");

683  
NULL
;

686 ià(
	`kvm_g‘sw­šfo
(
kd
, 
kvmsw
, 1, 0) < 0) {

687 
	`kvm_þo£
(
kd
);

688 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "kvm_getswapinfo failed");

689  
NULL
;

692 
	`kvm_þo£
(
kd
);

694 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_sw­š", &
sw­š
, &
size
, 
NULL
, 0) == -1)

695 
sbn_”rÜ
;

696 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_sw­out", &
sw­out
, &
size
, 
NULL
, 0) == -1)

697 
sbn_”rÜ
;

698 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_vnodeš", &
nodeš
, &
size
, 
NULL
, 0) == -1)

699 
sbn_”rÜ
;

700 ià(
	`sysùlbyÇme
("vm.¡©s.vm.v_vnodeout", &
nodeout
, &
size
, 
NULL
, 0) == -1)

701 
sbn_”rÜ
;

703  
	`Py_BuždV®ue
("(iiiII)",

704 
kvmsw
[0].
ksw_tÙ®
,

705 
kvmsw
[0].
ksw_u£d
,

706 
kvmsw
[0].
ksw_tÙ®
 - kvmsw[0].
ksw_u£d
,

707 
sw­š
 + 
sw­out
,

708 
nodeš
 + 
nodeout
);

710 
sbn_”rÜ
:

711 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

712  
NULL
;

713 
	}
}

719 
PyObjeù
 *

720 
	$psutž_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

722 
ýu_time
[
CPUSTATES
];

723 
size_t
 
size
;

725 
size
 = (
ýu_time
);

727 ià(
	`sysùlbyÇme
("k”n.ý_time", &
ýu_time
, &
size
, 
NULL
, 0) == -1) {

728 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

729  
NULL
;

732  
	`Py_BuždV®ue
("(ddddd)",

733 ()
ýu_time
[
CP_USER
] / 
CLOCKS_PER_SEC
,

734 ()
ýu_time
[
CP_NICE
] / 
CLOCKS_PER_SEC
,

735 ()
ýu_time
[
CP_SYS
] / 
CLOCKS_PER_SEC
,

736 ()
ýu_time
[
CP_IDLE
] / 
CLOCKS_PER_SEC
,

737 ()
ýu_time
[
CP_INTR
] / 
CLOCKS_PER_SEC


739 
	}
}

750 #ià
defšed
(
__F»eBSD_v”siÚ
) && __FreeBSD_version >= 800000

754 
PyObjeù
 *

755 
	$psutž_´oc_Ý’_fžes
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

757 
pid
;

758 
i
, 
út
;

759 
kšfo_fže
 *
ä“p
 = 
NULL
;

760 
kšfo_fže
 *
kif
;

761 
kšfo_´oc
 
kp
;

762 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

763 
PyObjeù
 *
tu¶e
 = 
NULL
;

765 ià(
»tLi¡
 =ð
NULL
)

766  
NULL
;

767 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
))

768 
”rÜ
;

769 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1)

770 
”rÜ
;

772 
ä“p
 = 
	`kšfo_g‘fže
(
pid
, &
út
);

773 ià(
ä“p
 =ð
NULL
) {

774 
	`psutž_¿i£_ad_Ü_n¥
(
pid
);

775 
”rÜ
;

778 
i
 = 0; i < 
út
; i++) {

779 
kif
 = &
ä“p
[
i
];

780 ià((
kif
->
kf_ty³
 =ð
KF_TYPE_VNODE
) &&

781 (
kif
->
kf_vnode_ty³
 =ð
KF_VTYPE_VREG
))

783 
tu¶e
 = 
	`Py_BuždV®ue
("(si)", 
kif
->
kf_·th
, kif->
kf_fd
);

784 ià(
tu¶e
 =ð
NULL
)

785 
”rÜ
;

786 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
tu¶e
))

787 
”rÜ
;

788 
	`Py_DECREF
(
tu¶e
);

791 
	`ä“
(
ä“p
);

792  
»tLi¡
;

794 
”rÜ
:

795 
	`Py_XDECREF
(
tu¶e
);

796 
	`Py_DECREF
(
»tLi¡
);

797 ià(
ä“p
 !ð
NULL
)

798 
	`ä“
(
ä“p
);

799  
NULL
;

800 
	}
}

806 
PyObjeù
 *

807 
	$psutž_´oc_num_fds
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

809 
pid
;

810 
út
;

812 
kšfo_fže
 *
ä“p
;

813 
kšfo_´oc
 
kp
;

815 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
))

816  
NULL
;

817 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1)

818  
NULL
;

820 
ä“p
 = 
	`kšfo_g‘fže
(
pid
, &
út
);

821 ià(
ä“p
 =ð
NULL
) {

822 
	`psutž_¿i£_ad_Ü_n¥
(
pid
);

823  
NULL
;

825 
	`ä“
(
ä“p
);

827  
	`Py_BuždV®ue
("i", 
út
);

828 
	}
}

834 
PyObjeù
 *

835 
	$psutž_´oc_cwd
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

837 
pid
;

838 
PyObjeù
 *
·th
 = 
NULL
;

839 
kšfo_fže
 *
ä“p
 = 
NULL
;

840 
kšfo_fže
 *
kif
;

841 
kšfo_´oc
 
kp
;

843 
i
, 
út
;

845 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
))

846 
”rÜ
;

847 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1)

848 
”rÜ
;

850 
ä“p
 = 
	`kšfo_g‘fže
(
pid
, &
út
);

851 ià(
ä“p
 =ð
NULL
) {

852 
	`psutž_¿i£_ad_Ü_n¥
(
pid
);

853 
”rÜ
;

856 
i
 = 0; i < 
út
; i++) {

857 
kif
 = &
ä“p
[
i
];

858 ià(
kif
->
kf_fd
 =ð
KF_FD_TYPE_CWD
) {

859 
·th
 = 
	`Py_BuždV®ue
("s", 
kif
->
kf_·th
);

860 ià(!
·th
)

861 
”rÜ
;

870 ià(
·th
 =ð
NULL
) {

871 
·th
 = 
	`Py_BuždV®ue
("s", "");

873 
	`ä“
(
ä“p
);

874  
·th
;

876 
”rÜ
:

877 
	`Py_XDECREF
(
·th
);

878 ià(
ä“p
 !ð
NULL
)

879 
	`ä“
(
ä“p
);

880  
NULL
;

881 
	}
}

886 
	$psutž_ãtch_týli¡
()

888 *
buf
;

889 
size_t
 
Ën
;

890 
”rÜ
;

893 ià(
	`sysùlbyÇme
("Ãt.š‘.tý.pcbli¡", 
NULL
, &
Ën
, NULL, 0) < 0) {

894 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

895  
NULL
;

897 
buf
 = 
	`m®loc
(
Ën
);

898 ià(
buf
 =ð
NULL
) {

899 
	`PyE¼_NoMemÜy
();

900  
NULL
;

902 ià(
	`sysùlbyÇme
("Ãt.š‘.tý.pcbli¡", 
buf
, &
Ën
, 
NULL
, 0) < 0) {

903 
	`ä“
(
buf
);

904 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

905  
NULL
;

907  
buf
;

909 
	}
}

912 
	$psutž_sockaddr_pÜt
(
çmžy
, 
sockaddr_¡Üage
 *
ss
)

914 
sockaddr_š6
 *
sš6
;

915 
sockaddr_š
 *
sš
;

917 ià(
çmžy
 =ð
AF_INET
) {

918 
sš
 = (
sockaddr_š
 *)
ss
;

919  (
sš
->
sš_pÜt
);

921 
sš6
 = (
sockaddr_š6
 *)
ss
;

922  (
sš6
->
sš6_pÜt
);

924 
	}
}

927 
	$psutž_sockaddr_addr
(
çmžy
, 
sockaddr_¡Üage
 *
ss
)

929 
sockaddr_š6
 *
sš6
;

930 
sockaddr_š
 *
sš
;

932 ià(
çmžy
 =ð
AF_INET
) {

933 
sš
 = (
sockaddr_š
 *)
ss
;

934  (&
sš
->
sš_addr
);

936 
sš6
 = (
sockaddr_š6
 *)
ss
;

937  (&
sš6
->
sš6_addr
);

939 
	}
}

941 
sockËn_t


942 
	$psutž_sockaddr_add¾’
(
çmžy
)

944 ià(
çmžy
 =ð
AF_INET
)

945  ((
š_addr
));

947  ((
š6_addr
));

948 
	}
}

951 
	$psutž_sockaddr_m©ches
(
çmžy
, 
pÜt
, *
pcb_addr
,

952 
sockaddr_¡Üage
 *
ss
)

954 ià(
	`psutž_sockaddr_pÜt
(
çmžy
, 
ss
è!ð
pÜt
)

956  (
	`memcmp
(
	`psutž_sockaddr_addr
(
çmžy
, 
ss
), 
pcb_addr
,

957 
	`psutž_sockaddr_add¾’
(
çmžy
)) == 0);

958 
	}
}

960 
týcb
 *

961 
	$psutž_£¬ch_týli¡
(*
buf
, 
kšfo_fže
 *
kif
)

963 
týcb
 *

;

964 
špcb
 *
šp
;

965 
xšpg’
 *
xig
, *
oxig
;

966 
xsock‘
 *
so
;

968 
oxig
 = 
xig
 = (
xšpg’
 *)
buf
;

969 
xig
 = (
xšpg’
 *)((*)xig + xig->
xig_Ën
);

970 
xig
->
xig_Ën
 > (
xšpg’
);

971 
xig
 = (
xšpg’
 *)((*)xig + xig->
xig_Ën
)) {

972 

 = &((
xtýcb
 *)
xig
)->
xt_
;

973 
šp
 = &((
xtýcb
 *)
xig
)->
xt_šp
;

974 
so
 = &((
xtýcb
 *)
xig
)->
xt_sock‘
;

976 ià(
so
->
so_ty³
 !ð
kif
->
kf_sock_ty³
 ||

977 
so
->
xso_çmžy
 !ð
kif
->
kf_sock_domaš
 ||

978 
so
->
xso_´ÙocÞ
 !ð
kif
->
kf_sock_´ÙocÞ
)

981 ià(
kif
->
kf_sock_domaš
 =ð
AF_INET
) {

982 ià(!
	`psutž_sockaddr_m©ches
(

983 
AF_INET
, 
šp
->
šp_ÍÜt
, &šp->
šp_Ïddr
,

984 &
kif
->
kf_§_loÿl
))

986 ià(!
	`psutž_sockaddr_m©ches
(

987 
AF_INET
, 
šp
->
šp_åÜt
, &šp->
šp_çddr
,

988 &
kif
->
kf_§_³”
))

991 ià(!
	`psutž_sockaddr_m©ches
(

992 
AF_INET6
, 
šp
->
šp_ÍÜt
, &šp->
š6p_Ïddr
,

993 &
kif
->
kf_§_loÿl
))

995 ià(!
	`psutž_sockaddr_m©ches
(

996 
AF_INET6
, 
šp
->
šp_åÜt
, &šp->
š6p_çddr
,

997 &
kif
->
kf_§_³”
))

1001  (

);

1003  
NULL
;

1004 
	}
}

1008 
	gPSUTIL_CONN_NONE
 = 128;

1013 
PyObjeù
 *

1014 
	$psutž_´oc_cÚÃùiÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1016 
pid
;

1017 
i
, 
út
;

1019 
kšfo_fže
 *
ä“p
 = 
NULL
;

1020 
kšfo_fže
 *
kif
;

1021 *
týli¡
 = 
NULL
;

1022 
týcb
 *
tý
;

1024 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

1025 
PyObjeù
 *
tu¶e
 = 
NULL
;

1026 
PyObjeù
 *
Ïddr
 = 
NULL
;

1027 
PyObjeù
 *
¿ddr
 = 
NULL
;

1028 
PyObjeù
 *
af_fž‹r
 = 
NULL
;

1029 
PyObjeù
 *
ty³_fž‹r
 = 
NULL
;

1030 
PyObjeù
 *
_çmžy
 = 
NULL
;

1031 
PyObjeù
 *
_ty³
 = 
NULL
;

1033 ià(
»tLi¡
 =ð
NULL
) {

1034  
NULL
;

1036 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lOO", &
pid
, &
af_fž‹r
, &
ty³_fž‹r
)) {

1037 
”rÜ
;

1039 ià(!
	`PySequ’û_Check
(
af_fž‹r
è|| !PySequ’û_Check(
ty³_fž‹r
)) {

1040 
	`PyE¼_S‘SŒšg
(
PyExc_Ty³E¼Ü
, "arg 2 or 3 is‚ot‡ sequence");

1041 
”rÜ
;

1044 
ä“p
 = 
	`kšfo_g‘fže
(
pid
, &
út
);

1045 ià(
ä“p
 =ð
NULL
) {

1046 
	`psutž_¿i£_ad_Ü_n¥
(
pid
);

1047 
”rÜ
;

1050 
týli¡
 = 
	`psutž_ãtch_týli¡
();

1051 ià(
týli¡
 =ð
NULL
) {

1052 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1053 
”rÜ
;

1056 
i
 = 0; i < 
út
; i++) {

1057 
ÍÜt
, 
½Üt
, 
¡©e
;

1058 
l
[200], 
r
[200];

1059 
·th
[
PATH_MAX
];

1060 
š£q
;

1061 
tu¶e
 = 
NULL
;

1062 
Ïddr
 = 
NULL
;

1063 
¿ddr
 = 
NULL
;

1065 
kif
 = &
ä“p
[
i
];

1066 ià(
kif
->
kf_ty³
 =ð
KF_TYPE_SOCKET
)

1069 
_çmžy
 = 
	`PyLÚg_FromLÚg
(()
kif
->
kf_sock_domaš
);

1070 
š£q
 = 
	`PySequ’û_Cڏšs
(
af_fž‹r
, 
_çmžy
);

1071 
	`Py_DECREF
(
_çmžy
);

1072 ià(
š£q
 == 0) {

1075 
_ty³
 = 
	`PyLÚg_FromLÚg
(()
kif
->
kf_sock_ty³
);

1076 
š£q
 = 
	`PySequ’û_Cڏšs
(
ty³_fž‹r
, 
_ty³
);

1077 
	`Py_DECREF
(
_ty³
);

1078 ià(
š£q
 == 0) {

1083 ià((
kif
->
kf_sock_domaš
 =ð
AF_INET
) ||

1084 (
kif
->
kf_sock_domaš
 =ð
AF_INET6
)) {

1086 
¡©e
 = 
PSUTIL_CONN_NONE
;

1087 ià(
kif
->
kf_sock_ty³
 =ð
SOCK_STREAM
) {

1088 
tý
 = 
	`psutž_£¬ch_týli¡
(
týli¡
, 
kif
);

1089 ià(
tý
 !ð
NULL
)

1090 
¡©e
 = ()
tý
->
t_¡©e
;

1094 
	`š‘_ÁÝ
(

1095 
kif
->
kf_sock_domaš
,

1096 
	`psutž_sockaddr_addr
(
kif
->
kf_sock_domaš
,

1097 &
kif
->
kf_§_loÿl
),

1098 
l
,

1099 (
l
));

1100 
	`š‘_ÁÝ
(

1101 
kif
->
kf_sock_domaš
,

1102 
	`psutž_sockaddr_addr
(
kif
->
kf_sock_domaš
,

1103 &
kif
->
kf_§_³”
),

1104 
r
,

1105 (
r
));

1106 
ÍÜt
 = 
	`htÚs
(
	`psutž_sockaddr_pÜt
(
kif
->
kf_sock_domaš
,

1107 &
kif
->
kf_§_loÿl
));

1108 
½Üt
 = 
	`htÚs
(
	`psutž_sockaddr_pÜt
(
kif
->
kf_sock_domaš
,

1109 &
kif
->
kf_§_³”
));

1112 
Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

1113 ià(!
Ïddr
)

1114 
”rÜ
;

1115 ià(
½Üt
 != 0) {

1116 
¿ddr
 = 
	`Py_BuždV®ue
("(si)", 
r
, 
½Üt
);

1119 
¿ddr
 = 
	`Py_BuždV®ue
("()");

1121 ià(!
¿ddr
)

1122 
”rÜ
;

1123 
tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNi)",

1124 
kif
->
kf_fd
,

1125 
kif
->
kf_sock_domaš
,

1126 
kif
->
kf_sock_ty³
,

1127 
Ïddr
,

1128 
¿ddr
,

1129 
¡©e
);

1130 ià(!
tu¶e
)

1131 
”rÜ
;

1132 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
tu¶e
))

1133 
”rÜ
;

1134 
	`Py_DECREF
(
tu¶e
);

1137 ià(
kif
->
kf_sock_domaš
 =ð
AF_UNIX
) {

1138 
sockaddr_un
 *
sun
;

1140 
sun
 = (
sockaddr_un
 *)&
kif
->
kf_§_loÿl
;

1141 
	`¢´štf
(

1142 
·th
, (path), "%.*s",

1143 (
sun
->
sun_Ën
 - ((*sunè- (sun->
sun_·th
))),

1144 
sun
->
sun_·th
);

1146 
tu¶e
 = 
	`Py_BuždV®ue
("(iiisOi)",

1147 
kif
->
kf_fd
,

1148 
kif
->
kf_sock_domaš
,

1149 
kif
->
kf_sock_ty³
,

1150 
·th
,

1151 
Py_NÚe
,

1152 
PSUTIL_CONN_NONE
);

1153 ià(!
tu¶e
)

1154 
”rÜ
;

1155 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
tu¶e
))

1156 
”rÜ
;

1157 
	`Py_DECREF
(
tu¶e
);

1158 
	`Py_INCREF
(
Py_NÚe
);

1162 
	`ä“
(
ä“p
);

1163 
	`ä“
(
týli¡
);

1164  
»tLi¡
;

1166 
”rÜ
:

1167 
	`Py_XDECREF
(
tu¶e
);

1168 
	`Py_XDECREF
(
Ïddr
);

1169 
	`Py_XDECREF
(
¿ddr
);

1170 
	`Py_DECREF
(
»tLi¡
);

1171 ià(
ä“p
 !ð
NULL
)

1172 
	`ä“
(
ä“p
);

1173 ià(
týli¡
 !ð
NULL
)

1174 
	`ä“
(
týli¡
);

1175  
NULL
;

1176 
	}
}

1182 
PyObjeù
 *

1183 
	$psutž_³r_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1185 
maxýus
;

1186 
mib
[2];

1187 
nýu
;

1188 
size_t
 
Ën
;

1189 
size_t
 
size
;

1190 
i
;

1191 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

1192 
PyObjeù
 *
py_ýutime
 = 
NULL
;

1194 ià(
py_»Ži¡
 =ð
NULL
)

1195  
NULL
;

1198 
size
 = (
maxýus
);

1199 ià(
	`sysùlbyÇme
("k”n.smp.maxýus", &
maxýus
, &
size
, 
NULL
, 0) < 0) {

1200 
	`Py_DECREF
(
py_»Ži¡
);

1201 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1202  
NULL
;

1204 
ýu_time
[
maxýus
][
CPUSTATES
];

1207 
mib
[0] = 
CTL_HW
;

1208 
mib
[1] = 
HW_NCPU
;

1209 
Ën
 = (
nýu
);

1210 ià(
	`sysùl
(
mib
, 2, &
nýu
, &
Ën
, 
NULL
, 0) == -1) {

1211 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1212 
”rÜ
;

1216 
size
 = (
ýu_time
);

1217 ià(
	`sysùlbyÇme
("k”n.ý_times", &
ýu_time
, &
size
, 
NULL
, 0) == -1) {

1218 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1219 
”rÜ
;

1222 
i
 = 0; i < 
nýu
; i++) {

1223 
py_ýutime
 = 
	`Py_BuždV®ue
(

1225 ()
ýu_time
[
i
][
CP_USER
] / 
CLOCKS_PER_SEC
,

1226 ()
ýu_time
[
i
][
CP_NICE
] / 
CLOCKS_PER_SEC
,

1227 ()
ýu_time
[
i
][
CP_SYS
] / 
CLOCKS_PER_SEC
,

1228 ()
ýu_time
[
i
][
CP_IDLE
] / 
CLOCKS_PER_SEC
,

1229 ()
ýu_time
[
i
][
CP_INTR
] / 
CLOCKS_PER_SEC
);

1230 ià(!
py_ýutime
)

1231 
”rÜ
;

1232 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_ýutime
))

1233 
”rÜ
;

1234 
	`Py_DECREF
(
py_ýutime
);

1237  
py_»Ži¡
;

1239 
”rÜ
:

1240 
	`Py_XDECREF
(
py_ýutime
);

1241 
	`Py_DECREF
(
py_»Ži¡
);

1242  
NULL
;

1243 
	}
}

1247 
	$»move_¥aûs
(*
¡r
) {

1248 *
p1
 = 
¡r
;

1249 *
p2
 = 
¡r
;

1251 *
p2
 == ' ')

1252 
p2
++;

1253 *
p1
++ = *
p2
++);

1254 
	}
}

1261 
PyObjeù
 *

1262 
	$psutž_´oc_memÜy_m­s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1264 
pid
;

1265 
±rwidth
;

1266 
i
, 
út
;

1267 
addr
[30];

1268 
³rms
[4];

1269 cÚ¡ *
·th
;

1270 
kšfo_´oc
 
kp
;

1271 
kšfo_vm’Œy
 *
ä“p
 = 
NULL
;

1272 
kšfo_vm’Œy
 *
kve
;

1273 
±rwidth
 = 2 * (*);

1274 
PyObjeù
 *
pytu¶e
 = 
NULL
;

1275 
PyObjeù
 *
»Ži¡
 = 
	`PyLi¡_New
(0);

1277 ià(
»Ži¡
 =ð
NULL
) {

1278  
NULL
;

1280 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1281 
”rÜ
;

1283 ià(
	`psutž_kšfo_´oc
(
pid
, &
kp
) == -1) {

1284 
”rÜ
;

1287 
ä“p
 = 
	`kšfo_g‘vmm­
(
pid
, &
út
);

1288 ià(
ä“p
 =ð
NULL
) {

1289 
	`psutž_¿i£_ad_Ü_n¥
(
pid
);

1290 
”rÜ
;

1292 
i
 = 0; i < 
út
; i++) {

1293 
pytu¶e
 = 
NULL
;

1294 
kve
 = &
ä“p
[
i
];

1295 
addr
[0] = '\0';

1296 
³rms
[0] = '\0';

1297 
	`¥rštf
(
addr
, "%#*jx-%#*jx", 
±rwidth
, (
uštmax_t
)
kve
->
kve_¡¬t
,

1298 
±rwidth
, (
uštmax_t
)
kve
->
kve_’d
);

1299 
	`»move_¥aûs
(
addr
);

1300 
	`¡¾ÿt
(
³rms
, 
kve
->
kve_´ÙeùiÚ
 & 
KVME_PROT_READ
 ? "r" : "-",

1301 (
³rms
));

1302 
	`¡¾ÿt
(
³rms
, 
kve
->
kve_´ÙeùiÚ
 & 
KVME_PROT_WRITE
 ? "w" : "-",

1303 (
³rms
));

1304 
	`¡¾ÿt
(
³rms
, 
kve
->
kve_´ÙeùiÚ
 & 
KVME_PROT_EXEC
 ? "x" : "-",

1305 (
³rms
));

1307 ià(
	`¡¾’
(
kve
->
kve_·th
) == 0) {

1308 
kve
->
kve_ty³
) {

1309 
KVME_TYPE_NONE
:

1310 
·th
 = "[none]";

1312 
KVME_TYPE_DEFAULT
:

1313 
·th
 = "[default]";

1315 
KVME_TYPE_VNODE
:

1316 
·th
 = "[vnode]";

1318 
KVME_TYPE_SWAP
:

1319 
·th
 = "[swap]";

1321 
KVME_TYPE_DEVICE
:

1322 
·th
 = "[device]";

1324 
KVME_TYPE_PHYS
:

1325 
·th
 = "[phys]";

1327 
KVME_TYPE_DEAD
:

1328 
·th
 = "[dead]";

1330 
KVME_TYPE_SG
:

1331 
·th
 = "[sg]";

1333 
KVME_TYPE_UNKNOWN
:

1334 
·th
 = "[unknown]";

1337 
·th
 = "[?]";

1342 
·th
 = 
kve
->
kve_·th
;

1345 
pytu¶e
 = 
	`Py_BuždV®ue
("sssiiii",

1346 
addr
,

1347 
³rms
,

1348 
·th
,

1349 
kve
->
kve_»sid’t
,

1350 
kve
->
kve_´iv©e_»sid’t
,

1351 
kve
->
kve_»f_couÁ
,

1352 
kve
->
kve_shadow_couÁ
);

1353 ià(!
pytu¶e
)

1354 
”rÜ
;

1355 ià(
	`PyLi¡_Aµ’d
(
»Ži¡
, 
pytu¶e
))

1356 
”rÜ
;

1357 
	`Py_DECREF
(
pytu¶e
);

1359 
	`ä“
(
ä“p
);

1360  
»Ži¡
;

1362 
”rÜ
:

1363 
	`Py_XDECREF
(
pytu¶e
);

1364 
	`Py_DECREF
(
»Ži¡
);

1365 ià(
ä“p
 !ð
NULL
)

1366 
	`ä“
(
ä“p
);

1367  
NULL
;

1368 
	}
}

1376 
PyObjeù
 *

1377 
	$psutž_disk_·¹™iÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1379 
num
;

1380 
i
;

1381 
Ën
;

1382 
ušt64_t
 
æags
;

1383 
Ýts
[200];

1384 
¡©fs
 *
fs
 = 
NULL
;

1385 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

1386 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

1388 ià(
py_»Ži¡
 =ð
NULL
)

1389  
NULL
;

1392 
Py_BEGIN_ALLOW_THREADS


1393 
num
 = 
	`g‘fs¡©
(
NULL
, 0, 
MNT_NOWAIT
);

1394 
Py_END_ALLOW_THREADS


1395 ià(
num
 == -1) {

1396 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1397 
”rÜ
;

1400 
Ën
 = (*
fs
è* 
num
;

1401 
fs
 = 
	`m®loc
(
Ën
);

1402 ià(
fs
 =ð
NULL
) {

1403 
	`PyE¼_NoMemÜy
();

1404 
”rÜ
;

1407 
Py_BEGIN_ALLOW_THREADS


1408 
num
 = 
	`g‘fs¡©
(
fs
, 
Ën
, 
MNT_NOWAIT
);

1409 
Py_END_ALLOW_THREADS


1410 ià(
num
 == -1) {

1411 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1412 
”rÜ
;

1415 
i
 = 0; i < 
num
; i++) {

1416 
py_tu¶e
 = 
NULL
;

1417 
Ýts
[0] = 0;

1418 
æags
 = 
fs
[
i
].
f_æags
;

1421 ià(
æags
 & 
MNT_RDONLY
)

1422 
	`¡¾ÿt
(
Ýts
, "ro", (opts));

1424 
	`¡¾ÿt
(
Ýts
, "rw", (opts));

1425 ià(
æags
 & 
MNT_SYNCHRONOUS
)

1426 
	`¡¾ÿt
(
Ýts
, ",sync", (opts));

1427 ià(
æags
 & 
MNT_NOEXEC
)

1428 
	`¡¾ÿt
(
Ýts
, ",noexec", (opts));

1429 ià(
æags
 & 
MNT_NOSUID
)

1430 
	`¡¾ÿt
(
Ýts
, ",nosuid", (opts));

1431 ià(
æags
 & 
MNT_UNION
)

1432 
	`¡¾ÿt
(
Ýts
, ",union", (opts));

1433 ià(
æags
 & 
MNT_ASYNC
)

1434 
	`¡¾ÿt
(
Ýts
, ",async", (opts));

1435 ià(
æags
 & 
MNT_SUIDDIR
)

1436 
	`¡¾ÿt
(
Ýts
, ",suiddir", (opts));

1437 ià(
æags
 & 
MNT_SOFTDEP
)

1438 
	`¡¾ÿt
(
Ýts
, ",softdep", (opts));

1439 ià(
æags
 & 
MNT_NOSYMFOLLOW
)

1440 
	`¡¾ÿt
(
Ýts
, ",nosymfollow", (opts));

1441 ià(
æags
 & 
MNT_GJOURNAL
)

1442 
	`¡¾ÿt
(
Ýts
, ",gjournal", (opts));

1443 ià(
æags
 & 
MNT_MULTILABEL
)

1444 
	`¡¾ÿt
(
Ýts
, ",multilabel", (opts));

1445 ià(
æags
 & 
MNT_ACLS
)

1446 
	`¡¾ÿt
(
Ýts
, ",acls", (opts));

1447 ià(
æags
 & 
MNT_NOATIME
)

1448 
	`¡¾ÿt
(
Ýts
, ",noatime", (opts));

1449 ià(
æags
 & 
MNT_NOCLUSTERR
)

1450 
	`¡¾ÿt
(
Ýts
, ",noclusterr", (opts));

1451 ià(
æags
 & 
MNT_NOCLUSTERW
)

1452 
	`¡¾ÿt
(
Ýts
, ",noclusterw", (opts));

1453 ià(
æags
 & 
MNT_NFS4ACLS
)

1454 
	`¡¾ÿt
(
Ýts
, ",nfs4acls", (opts));

1456 
py_tu¶e
 = 
	`Py_BuždV®ue
("(ssss)",

1457 
fs
[
i
].
f_mÁäomÇme
,

1458 
fs
[
i
].
f_mÁÚÇme
,

1459 
fs
[
i
].
f_f¡y³Çme
,

1460 
Ýts
);

1461 ià(!
py_tu¶e
)

1462 
”rÜ
;

1463 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

1464 
”rÜ
;

1465 
	`Py_DECREF
(
py_tu¶e
);

1468 
	`ä“
(
fs
);

1469  
py_»Ži¡
;

1471 
”rÜ
:

1472 
	`Py_XDECREF
(
py_tu¶e
);

1473 
	`Py_DECREF
(
py_»Ži¡
);

1474 ià(
fs
 !ð
NULL
)

1475 
	`ä“
(
fs
);

1476  
NULL
;

1477 
	}
}

1483 
PyObjeù
 *

1484 
	$psutž_Ãt_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1486 *
buf
 = 
NULL
, *
lim
, *
Ãxt
;

1487 
if_msghdr
 *
ifm
;

1488 
mib
[6];

1489 
size_t
 
Ën
;

1490 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

1491 
PyObjeù
 *
py_ifc_šfo
 = 
NULL
;

1492 ià(
py_»tdiù
 =ð
NULL
)

1493  
NULL
;

1495 
mib
[0] = 
CTL_NET
;

1496 
mib
[1] = 
PF_ROUTE
;

1497 
mib
[2] = 0;

1498 
mib
[3] = 0;

1499 
mib
[4] = 
NET_RT_IFLIST
;

1500 
mib
[5] = 0;

1502 ià(
	`sysùl
(
mib
, 6, 
NULL
, &
Ën
, NULL, 0) < 0) {

1503 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1504 
”rÜ
;

1507 
buf
 = 
	`m®loc
(
Ën
);

1508 ià(
buf
 =ð
NULL
) {

1509 
	`PyE¼_NoMemÜy
();

1510 
”rÜ
;

1513 ià(
	`sysùl
(
mib
, 6, 
buf
, &
Ën
, 
NULL
, 0) < 0) {

1514 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1515 
”rÜ
;

1518 
lim
 = 
buf
 + 
Ën
;

1520 
Ãxt
 = 
buf
;‚exˆ< 
lim
; ) {

1521 
py_ifc_šfo
 = 
NULL
;

1522 
ifm
 = (
if_msghdr
 *)
Ãxt
;

1523 
Ãxt
 +ð
ifm
->
ifm_msgËn
;

1525 ià(
ifm
->
ifm_ty³
 =ð
RTM_IFINFO
) {

1526 
if_msghdr
 *
if2m
 = (if_msghd¸*)
ifm
;

1527 
sockaddr_dl
 *
sdl
 = (sockaddr_dÈ*)(
if2m
 + 1);

1528 
ifc_Çme
[32];

1530 
	`¡ºýy
(
ifc_Çme
, 
sdl
->
sdl_d©a
, sdl->
sdl_Æ’
);

1531 
ifc_Çme
[
sdl
->
sdl_Æ’
] = 0;

1536 ià(
	`¡ºcmp
(
ifc_Çme
, "usbus", 5) == 0) {

1540 
py_ifc_šfo
 = 
	`Py_BuždV®ue
("(kkkkkkki)",

1541 
if2m
->
ifm_d©a
.
ifi_oby‹s
,

1542 
if2m
->
ifm_d©a
.
ifi_iby‹s
,

1543 
if2m
->
ifm_d©a
.
ifi_Ýack‘s
,

1544 
if2m
->
ifm_d©a
.
ifi_ack‘s
,

1545 
if2m
->
ifm_d©a
.
ifi_›¼Üs
,

1546 
if2m
->
ifm_d©a
.
ifi_Û¼Üs
,

1547 
if2m
->
ifm_d©a
.
ifi_iqdrÝs
,

1549 ià(!
py_ifc_šfo
)

1550 
”rÜ
;

1551 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
ifc_Çme
, 
py_ifc_šfo
))

1552 
”rÜ
;

1553 
	`Py_DECREF
(
py_ifc_šfo
);

1560 
	`ä“
(
buf
);

1561  
py_»tdiù
;

1563 
”rÜ
:

1564 
	`Py_XDECREF
(
py_ifc_šfo
);

1565 
	`Py_DECREF
(
py_»tdiù
);

1566 ià(
buf
 !ð
NULL
)

1567 
	`ä“
(
buf
);

1568  
NULL
;

1569 
	}
}

1575 
PyObjeù
 *

1576 
	$psutž_disk_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1578 
i
;

1579 
¡©šfo
 
¡©s
;

1581 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

1582 
PyObjeù
 *
py_disk_šfo
 = 
NULL
;

1583 ià(
py_»tdiù
 =ð
NULL
)

1584  
NULL
;

1586 ià(
	`dev¡©_checkv”siÚ
(
NULL
) < 0) {

1587 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "devstat_checkversion() failed");

1588 
”rÜ
;

1591 
¡©s
.
dšfo
 = (
devšfo
 *)
	`m®loc
((devinfo));

1592 ià(
¡©s
.
dšfo
 =ð
NULL
) {

1593 
	`PyE¼_NoMemÜy
();

1594 
”rÜ
;

1596 
	`bz”o
(
¡©s
.
dšfo
, (
devšfo
));

1598 ià(
	`dev¡©_g‘devs
(
NULL
, &
¡©s
) == -1) {

1599 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "devstat_getdevs() failed");

1600 
”rÜ
;

1603 
i
 = 0; i < 
¡©s
.
dšfo
->
numdevs
; i++) {

1604 
py_disk_šfo
 = 
NULL
;

1605 
dev¡©
 
cu¼’t
;

1606 
disk_Çme
[128];

1607 
cu¼’t
 = 
¡©s
.
dšfo
->
deviûs
[
i
];

1608 
	`¢´štf
(
disk_Çme
, (disk_name), "%s%d",

1609 
cu¼’t
.
deviû_Çme
,

1610 
cu¼’t
.
un™_numb”
);

1612 
py_disk_šfo
 = 
	`Py_BuždV®ue
(

1614 
cu¼’t
.
Ý”©iÚs
[
DEVSTAT_READ
],

1615 
cu¼’t
.
Ý”©iÚs
[
DEVSTAT_WRITE
],

1616 
cu¼’t
.
by‹s
[
DEVSTAT_READ
],

1617 
cu¼’t
.
by‹s
[
DEVSTAT_WRITE
],

1618 ()
	`dev¡©_compu‹_‘ime
(

1619 &
cu¼’t
.
du¿tiÚ
[
DEVSTAT_READ
], 
NULL
),

1620 ()
	`dev¡©_compu‹_‘ime
(

1621 &
cu¼’t
.
du¿tiÚ
[
DEVSTAT_WRITE
], 
NULL
));

1622 ià(!
py_disk_šfo
)

1623 
”rÜ
;

1624 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
disk_Çme
, 
py_disk_šfo
))

1625 
”rÜ
;

1626 
	`Py_DECREF
(
py_disk_šfo
);

1629 ià(
¡©s
.
dšfo
->
mem_±r
) {

1630 
	`ä“
(
¡©s
.
dšfo
->
mem_±r
);

1632 
	`ä“
(
¡©s
.
dšfo
);

1633  
py_»tdiù
;

1635 
”rÜ
:

1636 
	`Py_XDECREF
(
py_disk_šfo
);

1637 
	`Py_DECREF
(
py_»tdiù
);

1638 ià(
¡©s
.
dšfo
 !ð
NULL
)

1639 
	`ä“
(
¡©s
.
dšfo
);

1640  
NULL
;

1641 
	}
}

1647 
PyObjeù
 *

1648 
	$psutž_u£rs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1650 
PyObjeù
 *
»t_li¡
 = 
	`PyLi¡_New
(0);

1651 
PyObjeù
 *
tu¶e
 = 
NULL
;

1653 ià(
»t_li¡
 =ð
NULL
)

1654  
NULL
;

1656 #ià
__F»eBSD_v”siÚ
 < 900000

1657 
utmp
 
ut
;

1658 
FILE
 *
å
;

1660 
å
 = 
	`fÝ’
(
_PATH_UTMP
, "r");

1661 ià(
å
 =ð
NULL
) {

1662 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1663 
”rÜ
;

1666 
	`ä—d
(&
ut
, (ut), 1, 
å
) == 1) {

1667 ià(*
ut
.
ut_Çme
 == '\0')

1669 
tu¶e
 = 
	`Py_BuždV®ue
(

1671 
ut
.
ut_Çme
,

1672 
ut
.
ut_lše
,

1673 
ut
.
ut_ho¡
,

1674 ()
ut
.
ut_time
);

1675 ià(!
tu¶e
) {

1676 
	`fþo£
(
å
);

1677 
”rÜ
;

1679 ià(
	`PyLi¡_Aµ’d
(
»t_li¡
, 
tu¶e
)) {

1680 
	`fþo£
(
å
);

1681 
”rÜ
;

1683 
	`Py_DECREF
(
tu¶e
);

1686 
	`fþo£
(
å
);

1688 
utmpx
 *
utx
;

1690 (
utx
 = 
	`g‘utx’t
()è!ð
NULL
) {

1691 ià(
utx
->
ut_ty³
 !ð
USER_PROCESS
)

1693 
tu¶e
 = 
	`Py_BuždV®ue
(

1695 
utx
->
ut_u£r
,

1696 
utx
->
ut_lše
,

1697 
utx
->
ut_ho¡
,

1698 ()
utx
->
ut_tv
.
tv_£c


1701 ià(!
tu¶e
) {

1702 
	`’dutx’t
();

1703 
”rÜ
;

1705 ià(
	`PyLi¡_Aµ’d
(
»t_li¡
, 
tu¶e
)) {

1706 
	`’dutx’t
();

1707 
”rÜ
;

1709 
	`Py_DECREF
(
tu¶e
);

1712 
	`’dutx’t
();

1714  
»t_li¡
;

1716 
”rÜ
:

1717 
	`Py_XDECREF
(
tu¶e
);

1718 
	`Py_DECREF
(
»t_li¡
);

1719  
NULL
;

1720 
	}
}

1728 

	#HASHSIZE
 1009

	)

1729 
xfže
 *
	gpsutž_xfžes
;

1730 
	gpsutž_nxfžes
;

1733 
	$psutž_pÝuÏ‹_xfžes
()

1735 
size_t
 
Ën
;

1737 ià((
psutž_xfžes
 = 
	`m®loc
(
Ën
 =  *psutž_xfžes)è=ð
NULL
) {

1738 
	`PyE¼_NoMemÜy
();

1741 
	`sysùlbyÇme
("k”n.fže", 
psutž_xfžes
, &
Ën
, 0, 0) == -1) {

1742 ià(
Ӽo
 !ð
ENOMEM
) {

1743 
	`PyE¼_S‘FromE¼no
(0);

1746 
Ën
 *= 2;

1747 ià((
psutž_xfžes
 = 
	`»®loc
Õsutž_xfžes, 
Ën
)è=ð
NULL
) {

1748 
	`PyE¼_NoMemÜy
();

1752 ià(
Ën
 > 0 && 
psutž_xfžes
->
xf_size
 !=  *psutil_xfiles) {

1753 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "struct xfile size mismatch");

1756 
psutž_nxfžes
 = 
Ën
 /  *
psutž_xfžes
;

1758 
	}
}

1761 
	$psutž_g‘_pid_äom_sock
(
sock_hash
)

1763 
xfže
 *
xf
;

1764 
hash
, 
n
;

1765 
xf
 = 
psutž_xfžes
, 
n
 = 0;‚ < 
psutž_nxfžes
; ++n, ++xf) {

1766 ià(
xf
->
xf_d©a
 =ð
NULL
)

1768 
hash
 = ()((
ušŒ_t
)
xf
->
xf_d©a
 % 
HASHSIZE
);

1769 ià(
sock_hash
 =ð
hash
) {

1770  
xf
->
xf_pid
;

1774 
	}
}

1777 
	$psutž_g©h”_š‘
(
´Ùo
, 
PyObjeù
 *
py_»Ži¡
)

1779 
xšpg’
 *
xig
, *
exig
;

1780 
xšpcb
 *
x
;

1781 
xtýcb
 *
x
;

1782 
špcb
 *
šp
;

1783 
xsock‘
 *
so
;

1784 
sock
 *sock;

1785 cÚ¡ *
v‚me
;

1786 
size_t
 
Ën
, 
bufsize
;

1787 *
buf
;

1788 
hash
, 
»Œy
, 
væag
, 
ty³
;

1790 
PyObjeù
 *
tu¶e
 = 
NULL
;

1791 
PyObjeù
 *
Ïddr
 = 
NULL
;

1792 
PyObjeù
 *
¿ddr
 = 
NULL
;

1794 
´Ùo
) {

1795 
IPPROTO_TCP
:

1796 
v‚me
 = "net.inet.tcp.pcblist";

1797 
ty³
 = 
SOCK_STREAM
;

1799 
IPPROTO_UDP
:

1800 
v‚me
 = "net.inet.udp.pcblist";

1801 
ty³
 = 
SOCK_DGRAM
;

1805 
buf
 = 
NULL
;

1806 
bufsize
 = 8192;

1807 
»Œy
 = 5;

1810 
buf
 = 
	`»®loc
(buf, 
bufsize
);

1811 ià(
buf
 =ð
NULL
) {

1815 
Ën
 = 
bufsize
;

1816 ià(
	`sysùlbyÇme
(
v‚me
, 
buf
, &
Ën
, 
NULL
, 0) == 0)

1818 ià(
Ӽo
 !ð
ENOMEM
) {

1819 
	`PyE¼_S‘FromE¼no
(0);

1820 
”rÜ
;

1822 
bufsize
 *= 2;

1824 
xig
 = (
xšpg’
 *)
buf
;

1825 
exig
 = (
xšpg’
 *)(*)((*)
buf
 + 
Ën
 -  *exig);

1826 ià(
xig
->
xig_Ën
 !ð *xig || 
exig
->xig_len !=  *exig) {

1827 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "struct xinpgen size mismatch");

1828 
”rÜ
;

1830 } 
xig
->
xig_g’
 !ð
exig
->xig_g’ && 
»Œy
--);

1834 
xig
 = (
xšpg’
 *)(*)((*)xig + xig->
xig_Ën
);

1835 ià(
xig
 >ð
exig
)

1838 
´Ùo
) {

1839 
IPPROTO_TCP
:

1840 
x
 = (
xtýcb
 *)
xig
;

1841 ià(
x
->
xt_Ën
 !=  *xtp) {

1842 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "struct xtcpcb size mismatch");

1843 
”rÜ
;

1846 
IPPROTO_UDP
:

1847 
x
 = (
xšpcb
 *)
xig
;

1848 ià(
x
->
xi_Ën
 !=  *xip) {

1849 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "struct xinpcb size mismatch");

1850 
”rÜ
;

1852 
šp
 = &
x
->
xi_šp
;

1853 
so
 = &
x
->
xi_sock‘
;

1857 
šp
 = &
x
->
xt_šp
;

1858 
so
 = &
x
->
xt_sock‘
;

1859 
l
[200], 
r
[200];

1860 
çmžy
, 
ÍÜt
, 
½Üt
, 
pid
, 
¡©us
;

1862 
hash
 = ()((
ušŒ_t
)
so
->
xso_so
 % 
HASHSIZE
);

1863 
pid
 = 
	`psutž_g‘_pid_äom_sock
(
hash
);

1864 ià(
pid
 < 0)

1866 
ÍÜt
 = 
	`Áohs
(
šp
->
šp_ÍÜt
);

1867 
½Üt
 = 
	`Áohs
(
šp
->
šp_åÜt
);

1868 
¡©us
 = 
x
->
xt_
.
t_¡©e
;

1870 ià(
šp
->
šp_væag
 & 
INP_IPV4
) {

1871 
çmžy
 = 
AF_INET
;

1872 
	`š‘_ÁÝ
(
AF_INET
, &
šp
->
šp_Ïddr
.
s_addr
, 
l
, (lip));

1873 
	`š‘_ÁÝ
(
AF_INET
, &
šp
->
šp_çddr
.
s_addr
, 
r
, (rip));

1875 ià(
šp
->
šp_væag
 & 
INP_IPV6
) {

1876 
çmžy
 = 
AF_INET6
;

1877 
	`š‘_ÁÝ
(
AF_INET6
, &
šp
->
š6p_Ïddr
.
s6_addr
, 
l
, (lip));

1878 
	`š‘_ÁÝ
(
AF_INET6
, &
šp
->
š6p_çddr
.
s6_addr
, 
r
, (rip));

1882 
Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

1883 ià(!
Ïddr
)

1884 
”rÜ
;

1885 ià(
½Üt
 != 0) {

1886 
¿ddr
 = 
	`Py_BuždV®ue
("(si)", 
r
, 
½Üt
);

1889 
¿ddr
 = 
	`Py_BuždV®ue
("()");

1891 ià(!
¿ddr
)

1892 
”rÜ
;

1893 
tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNii)", -1, 
çmžy
, 
ty³
, 
Ïddr
, 
¿ddr
,

1894 
¡©us
, 
pid
);

1895 ià(!
tu¶e
)

1896 
”rÜ
;

1897 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
tu¶e
))

1898 
”rÜ
;

1899 
	`Py_DECREF
(
tu¶e
);

1902 
	`ä“
(
buf
);

1905 
”rÜ
:

1906 
	`Py_XDECREF
(
tu¶e
);

1907 
	`Py_XDECREF
(
Ïddr
);

1908 
	`Py_XDECREF
(
¿ddr
);

1909 
	`ä“
(
buf
);

1911 
	}
}

1914 
	$psutž_g©h”_unix
(
´Ùo
, 
PyObjeù
 *
py_»Ži¡
)

1916 
xuÅg’
 *
xug
, *
exug
;

1917 
xuÅcb
 *
xup
;

1918 
sock
 *sock;

1919 cÚ¡ *
v‚me
, *
´ÙÚame
;

1920 
size_t
 
Ën
, 
bufsize
;

1921 *
buf
;

1922 
hash
, 
»Œy
;

1923 
çmžy
, 
ÍÜt
, 
½Üt
, 
pid
;

1924 
sockaddr_un
 *
sun
;

1925 
·th
[
PATH_MAX
];

1927 
PyObjeù
 *
tu¶e
 = 
NULL
;

1928 
PyObjeù
 *
Ïddr
 = 
NULL
;

1929 
PyObjeù
 *
¿ddr
 = 
NULL
;

1931 
´Ùo
) {

1932 
SOCK_STREAM
:

1933 
v‚me
 = "net.local.stream.pcblist";

1934 
´ÙÚame
 = "stream";

1936 
SOCK_DGRAM
:

1937 
v‚me
 = "net.local.dgram.pcblist";

1938 
´ÙÚame
 = "dgram";

1942 
buf
 = 
NULL
;

1943 
bufsize
 = 8192;

1944 
»Œy
 = 5;

1948 
buf
 = 
	`»®loc
(buf, 
bufsize
);

1949 ià(
buf
 =ð
NULL
) {

1950 
	`PyE¼_NoMemÜy
();

1951 
”rÜ
;

1953 
Ën
 = 
bufsize
;

1954 ià(
	`sysùlbyÇme
(
v‚me
, 
buf
, &
Ën
, 
NULL
, 0) == 0)

1956 ià(
Ӽo
 !ð
ENOMEM
) {

1957 
	`PyE¼_S‘FromE¼no
(0);

1958 
”rÜ
;

1960 
bufsize
 *= 2;

1962 
xug
 = (
xuÅg’
 *)
buf
;

1963 
exug
 = (
xuÅg’
 *)(*)

1964 ((*)
buf
 + 
Ën
 -  *
exug
);

1965 ià(
xug
->
xug_Ën
 !ð *xug || 
exug
->xug_len !=  *exug) {

1966 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "struct xinpgen size mismatch");

1967 
”rÜ
;

1969 } 
xug
->
xug_g’
 !ð
exug
->xug_g’ && 
»Œy
--);

1972 
xug
 = (
xuÅg’
 *)(*)((*)xug + xug->
xug_Ën
);

1973 ià(
xug
 >ð
exug
)

1975 
xup
 = (
xuÅcb
 *)
xug
;

1976 ià(
xup
->
xu_Ën
 !=  *xup) {

1977 
	`w¬nx
("struct xunpgen size mismatch");

1978 
”rÜ
;

1981 
hash
 = ()((
ušŒ_t
è
xup
->
xu_sock‘
.
xso_so
 % 
HASHSIZE
);

1982 
pid
 = 
	`psutž_g‘_pid_äom_sock
(
hash
);

1983 ià(
pid
 < 0)

1986 
sun
 = (
sockaddr_un
 *)&
xup
->
xu_addr
;

1987 
	`¢´štf
(
·th
, (path), "%.*s",

1988 (
sun
->
sun_Ën
 - ((*sunè- (sun->
sun_·th
))),

1989 
sun
->
sun_·th
);

1991 
tu¶e
 = 
	`Py_BuždV®ue
("(iiisOii)", -1, 
AF_UNIX
, 
´Ùo
, 
·th
, 
Py_NÚe
,

1992 
PSUTIL_CONN_NONE
, 
pid
);

1993 ià(!
tu¶e
)

1994 
”rÜ
;

1995 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
tu¶e
))

1996 
”rÜ
;

1997 
	`Py_DECREF
(
tu¶e
);

1998 
	`Py_INCREF
(
Py_NÚe
);

2001 
	`ä“
(
buf
);

2004 
”rÜ
:

2005 
	`Py_XDECREF
(
tu¶e
);

2006 
	`Py_XDECREF
(
Ïddr
);

2007 
	`Py_XDECREF
(
¿ddr
);

2008 
	`ä“
(
buf
);

2010 
	}
}

2016 
PyObjeù
*

2017 
	$psutž_Ãt_cÚÃùiÚs
(
PyObjeù
* 
£lf
, PyObjeù* 
¬gs
)

2019 
PyObjeù
 *
af_fž‹r
 = 
NULL
;

2020 
PyObjeù
 *
ty³_fž‹r
 = 
NULL
;

2021 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

2023 ià(
	`psutž_pÝuÏ‹_xfžes
() != 1)

2024 
”rÜ
;

2026 ià(
	`psutž_g©h”_š‘
(
IPPROTO_TCP
, 
py_»Ži¡
) == 0)

2027 
”rÜ
;

2028 ià(
	`psutž_g©h”_š‘
(
IPPROTO_UDP
, 
py_»Ži¡
) == 0)

2029 
”rÜ
;

2030 ià(
	`psutž_g©h”_unix
(
SOCK_STREAM
, 
py_»Ži¡
) == 0)

2031 
”rÜ
;

2032 ià(
	`psutž_g©h”_unix
(
SOCK_DGRAM
, 
py_»Ži¡
) == 0)

2033 
”rÜ
;

2035 
	`ä“
(
psutž_xfžes
);

2036  
py_»Ži¡
;

2038 
”rÜ
:

2039 
	`Py_DECREF
(
py_»Ži¡
);

2040 
	`ä“
(
psutž_xfžes
);

2041  
NULL
;

2042 
	}
}

2048 
PyM‘hodDef


2049 
	gPsutžM‘hods
[] =

2053 {"´oc_Çme", 
psutž_´oc_Çme
, 
METH_VARARGS
,

2055 {"´oc_cÚÃùiÚs", 
psutž_´oc_cÚÃùiÚs
, 
METH_VARARGS
,

2057 {"´oc_exe", 
psutž_´oc_exe
, 
METH_VARARGS
,

2059 {"´oc_cmdlše", 
psutž_´oc_cmdlše
, 
METH_VARARGS
,

2061 {"´oc_µid", 
psutž_´oc_µid
, 
METH_VARARGS
,

2063 {"´oc_uids", 
psutž_´oc_uids
, 
METH_VARARGS
,

2065 {"´oc_gids", 
psutž_´oc_gids
, 
METH_VARARGS
,

2067 {"´oc_ýu_times", 
psutž_´oc_ýu_times
, 
METH_VARARGS
,

2069 {"´oc_ü—‹_time", 
psutž_´oc_ü—‹_time
, 
METH_VARARGS
,

2072 {"´oc_memÜy_šfo", 
psutž_´oc_memÜy_šfo
, 
METH_VARARGS
,

2074 {"´oc_num_th»ads", 
psutž_´oc_num_th»ads
, 
METH_VARARGS
,

2076 {"´oc_num_ùx_sw™ches", 
psutž_´oc_num_ùx_sw™ches
, 
METH_VARARGS
,

2078 {"´oc_th»ads", 
psutž_´oc_th»ads
, 
METH_VARARGS
,

2080 {"´oc_¡©us", 
psutž_´oc_¡©us
, 
METH_VARARGS
,

2082 {"´oc_io_couÁ”s", 
psutž_´oc_io_couÁ”s
, 
METH_VARARGS
,

2084 {"´oc_‰y_Ä", 
psutž_´oc_‰y_Ä
, 
METH_VARARGS
,

2086 #ià
defšed
(
__F»eBSD_v”siÚ
) && __FreeBSD_version >= 800000

2087 {"´oc_Ý’_fžes", 
psutž_´oc_Ý’_fžes
, 
METH_VARARGS
,

2089 {"´oc_cwd", 
psutž_´oc_cwd
, 
METH_VARARGS
,

2091 {"´oc_memÜy_m­s", 
psutž_´oc_memÜy_m­s
, 
METH_VARARGS
,

2093 {"´oc_num_fds", 
psutž_´oc_num_fds
, 
METH_VARARGS
,

2099 {"pids", 
psutž_pids
, 
METH_VARARGS
,

2101 {"ýu_couÁ_logiÿl", 
psutž_ýu_couÁ_logiÿl
, 
METH_VARARGS
,

2103 {"ýu_couÁ_phys", 
psutž_ýu_couÁ_phys
, 
METH_VARARGS
,

2105 {"vœtu®_mem", 
psutž_vœtu®_mem
, 
METH_VARARGS
,

2107 {"sw­_mem", 
psutž_sw­_mem
, 
METH_VARARGS
,

2109 {"ýu_times", 
psutž_ýu_times
, 
METH_VARARGS
,

2111 #ià
defšed
(
__F»eBSD_v”siÚ
) && __FreeBSD_version >= 800000

2112 {"³r_ýu_times", 
psutž_³r_ýu_times
, 
METH_VARARGS
,

2115 {"boÙ_time", 
psutž_boÙ_time
, 
METH_VARARGS
,

2117 {"disk_·¹™iÚs", 
psutž_disk_·¹™iÚs
, 
METH_VARARGS
,

2120 {"Ãt_io_couÁ”s", 
psutž_Ãt_io_couÁ”s
, 
METH_VARARGS
,

2122 {"disk_io_couÁ”s", 
psutž_disk_io_couÁ”s
, 
METH_VARARGS
,

2124 {"u£rs", 
psutž_u£rs
, 
METH_VARARGS
,

2126 {"Ãt_cÚÃùiÚs", 
psutž_Ãt_cÚÃùiÚs
, 
METH_VARARGS
,

2129 {
NULL
, NULL, 0, NULL}

2132 
	smoduË_¡©e
 {

2133 
PyObjeù
 *
	m”rÜ
;

2136 #ià
PY_MAJOR_VERSION
 >= 3

2137 

	#GETSTATE
(
m
è((
moduË_¡©e
*)
	`PyModuË_G‘S‹
(m))

	)

2139 

	#GETSTATE
(
m
è(&
_¡©e
)

	)

2142 #ià
PY_MAJOR_VERSION
 >= 3

2145 
	$psutž_bsd_Œav”£
(
PyObjeù
 *
m
, 
vis™´oc
 
vis™
, *
¬g
) {

2146 
	`Py_VISIT
(
	`GETSTATE
(
m
)->
”rÜ
);

2148 
	}
}

2151 
	$psutž_bsd_þ—r
(
PyObjeù
 *
m
) {

2152 
	`Py_CLEAR
(
	`GETSTATE
(
m
)->
”rÜ
);

2154 
	}
}

2156 
PyModuËDef


2157 
	gmoduËdef
 = {

2158 
PyModuËDef_HEAD_INIT
,

2160 
NULL
,

2161 (
moduË_¡©e
),

2162 
PsutžM‘hods
,

2163 
NULL
,

2164 
psutž_bsd_Œav”£
,

2165 
psutž_bsd_þ—r
,

2166 
NULL


2169 

	#INITERROR
  
NULL


	)

2171 
PyMODINIT_FUNC
 
	$PyIn™__psutž_bsd
()

2174 

	#INITERROR
 

	)

2176 
	$š™_psutž_bsd
()

2179 #ià
PY_MAJOR_VERSION
 >= 3

2180 
PyObjeù
 *
moduË
 = 
	`PyModuË_C»©e
(&
moduËdef
);

2182 
PyObjeù
 *
moduË
 = 
	`Py_In™ModuË
("_psutž_bsd", 
PsutžM‘hods
);

2185 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SSTOP", 
SSTOP
);

2186 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SSLEEP", 
SSLEEP
);

2187 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SRUN", 
SRUN
);

2188 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SIDL", 
SIDL
);

2189 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SWAIT", 
SWAIT
);

2190 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SLOCK", 
SLOCK
);

2191 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SZOMB", 
SZOMB
);

2193 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSED", 
TCPS_CLOSED
);

2194 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSING", 
TCPS_CLOSING
);

2195 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSE_WAIT", 
TCPS_CLOSE_WAIT
);

2196 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_LISTEN", 
TCPS_LISTEN
);

2197 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_ESTABLISHED", 
TCPS_ESTABLISHED
);

2198 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_SYN_SENT", 
TCPS_SYN_SENT
);

2199 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_SYN_RECEIVED", 
TCPS_SYN_RECEIVED
);

2200 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_FIN_WAIT_1", 
TCPS_FIN_WAIT_1
);

2201 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_FIN_WAIT_2", 
TCPS_FIN_WAIT_2
);

2202 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_LAST_ACK", 
TCPS_LAST_ACK
);

2203 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_TIME_WAIT", 
TCPS_TIME_WAIT
);

2204 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "PSUTIL_CONN_NONE", 
PSUTIL_CONN_NONE
);

2206 ià(
moduË
 =ð
NULL
) {

2207 
INITERROR
;

2209 #ià
PY_MAJOR_VERSION
 >= 3

2210  
moduË
;

2212 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_bsd.h

7 
	~<PythÚ.h
>

11 
PyObjeù
* 
psutž_´oc_cmdlše
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

12 
PyObjeù
* 
psutž_´oc_cÚÃùiÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

13 
PyObjeù
* 
psutž_´oc_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

14 
PyObjeù
* 
psutž_´oc_ü—‹_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

15 
PyObjeù
* 
psutž_´oc_exe
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

16 
PyObjeù
* 
psutž_´oc_gids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

17 
PyObjeù
* 
psutž_´oc_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

18 
PyObjeù
* 
psutž_´oc_memÜy_šfo
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

19 
PyObjeù
* 
psutž_´oc_memÜy_m­s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

20 
PyObjeù
* 
psutž_´oc_Çme
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

21 
PyObjeù
* 
psutž_´oc_num_ùx_sw™ches
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

22 
PyObjeù
* 
psutž_´oc_num_fds
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

23 
PyObjeù
* 
psutž_´oc_num_th»ads
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

24 
PyObjeù
* 
psutž_´oc_µid
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

25 
PyObjeù
* 
psutž_´oc_¡©us
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

26 
PyObjeù
* 
psutž_´oc_th»ads
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

27 
PyObjeù
* 
psutž_´oc_‰y_Ä
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

28 
PyObjeù
* 
psutž_´oc_uids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

30 #ià
defšed
(
__F»eBSD_v”siÚ
) && __FreeBSD_version >= 800000

31 
PyObjeù
* 
psutž_´oc_Ý’_fžes
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

32 
PyObjeù
* 
psutž_´oc_cwd
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

37 
PyObjeù
* 
psutž_boÙ_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

38 
PyObjeù
* 
psutž_ýu_couÁ_logiÿl
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

39 
PyObjeù
* 
psutž_ýu_couÁ_phys
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

40 
PyObjeù
* 
psutž_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

41 
PyObjeù
* 
psutž_disk_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

42 
PyObjeù
* 
psutž_disk_·¹™iÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

43 
PyObjeù
* 
psutž_Ãt_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

44 
PyObjeù
* 
psutž_pids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

45 
PyObjeù
* 
psutž_sw­_mem
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

46 
PyObjeù
* 
psutž_u£rs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

47 
PyObjeù
* 
psutž_vœtu®_mem
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

49 #ià
defšed
(
__F»eBSD_v”siÚ
) && __FreeBSD_version >= 800000

50 
PyObjeù
* 
psutž_³r_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_common.c

9 
	~<PythÚ.h
>

15 
PyObjeù
 *

16 
	$NoSuchProûss
() {

17 
PyObjeù
 *
exc
;

18 *
msg
 = 
	`¡»¼Ü
(
ESRCH
);

19 
exc
 = 
	`PyObjeù_C®lFunùiÚ
(
PyExc_OSE¼Ü
, "(is)", 
ESRCH
, 
msg
);

20 
	`PyE¼_S‘Objeù
(
PyExc_OSE¼Ü
, 
exc
);

21 
	`Py_XDECREF
(
exc
);

22  
NULL
;

23 
	}
}

29 
PyObjeù
 *

30 
	$AcûssD’›d
() {

31 
PyObjeù
 *
exc
;

32 *
msg
 = 
	`¡»¼Ü
(
EACCES
);

33 
exc
 = 
	`PyObjeù_C®lFunùiÚ
(
PyExc_OSE¼Ü
, "(is)", 
EACCES
, 
msg
);

34 
	`PyE¼_S‘Objeù
(
PyExc_OSE¼Ü
, 
exc
);

35 
	`Py_XDECREF
(
exc
);

36  
NULL
;

37 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_common.h

7 
	~<PythÚ.h
>

9 
PyObjeù
* 
AcûssD’›d
();

10 
PyObjeù
* 
NoSuchProûss
();

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_linux.c

9 #iâdeà
_GNU_SOURCE


10 

	#_GNU_SOURCE
 1

	)

12 
	~<PythÚ.h
>

13 
	~<Ӽo.h
>

14 
	~<¡dlib.h
>

15 
	~<mÁ’t.h
>

16 
	~<ã©u»s.h
>

17 
	~<utmp.h
>

18 
	~<sched.h
>

19 
	~<lšux/v”siÚ.h
>

20 
	~<sys/sysÿÎ.h
>

21 
	~<sys/sysšfo.h
>

23 
	~"_psutž_lšux.h
"

27 

	#PSUTIL_HAVE_IOPRIO
 
	`defšed
(
__NR_iÝrio_g‘
è&& defšed(
__NR_iÝrio_£t
)

	)

30 

	#PSUTIL_HAVE_PRLIMIT
 \

31 (
LINUX_VERSION_CODE
 >ð
	`KERNEL_VERSION
(2, 6, 36)) && \

32 (
__GLIBC__
 >ð2 && 
__GLIBC_MINOR__
 >= 13) && \

33 
	`defšed
(
__NR_´lim™64
)

	)

35 #ià
PSUTIL_HAVE_PRLIMIT


36 

	#_FILE_OFFSET_BITS
 64

	)

37 
	~<time.h
>

38 
	~<sys/»sourû.h
>

42 #ià
PSUTIL_HAVE_IOPRIO


44 
	mIOPRIO_WHO_PROCESS
 = 1,

47 
šlše
 

48 
	$iÝrio_g‘
(
which
, 
who
)

50  
	`sysÿÎ
(
__NR_iÝrio_g‘
, 
which
, 
who
);

51 
	}
}

53 
šlše
 

54 
	$iÝrio_£t
(
which
, 
who
, 
iÝrio
)

56  
	`sysÿÎ
(
__NR_iÝrio_£t
, 
which
, 
who
, 
iÝrio
);

57 
	}
}

59 

	#IOPRIO_CLASS_SHIFT
 13

	)

60 

	#IOPRIO_PRIO_MASK
 ((1UL << 
IOPRIO_CLASS_SHIFT
è- 1)

	)

62 

	#IOPRIO_PRIO_CLASS
(
mask
è((maskè>> 
IOPRIO_CLASS_SHIFT
)

	)

63 

	#IOPRIO_PRIO_DATA
(
mask
è((maskè& 
IOPRIO_PRIO_MASK
)

	)

64 

	#IOPRIO_PRIO_VALUE
(
þass
, 
d©a
è(((þassè<< 
IOPRIO_CLASS_SHIFT
è| d©a)

	)

70 
PyObjeù
 *

71 
	$psutž_´oc_iÝrio_g‘
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

73 
pid
;

74 
iÝrio
, 
ioþass
, 
iod©a
;

75 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

76  
NULL
;

78 
iÝrio
 = 
	`iÝrio_g‘
(
IOPRIO_WHO_PROCESS
, 
pid
);

79 ià(
iÝrio
 == -1) {

80  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

82 
ioþass
 = 
	`IOPRIO_PRIO_CLASS
(
iÝrio
);

83 
iod©a
 = 
	`IOPRIO_PRIO_DATA
(
iÝrio
);

84  
	`Py_BuždV®ue
("ii", 
ioþass
, 
iod©a
);

85 
	}
}

93 
PyObjeù
 *

94 
	$psutž_´oc_iÝrio_£t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

96 
pid
;

97 
iÝrio
, 
ioþass
, 
iod©a
;

98 
»tv®
;

100 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lii", &
pid
, &
ioþass
, &
iod©a
)) {

101  
NULL
;

103 
iÝrio
 = 
	`IOPRIO_PRIO_VALUE
(
ioþass
, 
iod©a
);

104 
»tv®
 = 
	`iÝrio_£t
(
IOPRIO_WHO_PROCESS
, 
pid
, 
iÝrio
);

105 ià(
»tv®
 == -1) {

106  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

108 
	`Py_INCREF
(
Py_NÚe
);

109  
Py_NÚe
;

110 
	}
}

114 #ià
PSUTIL_HAVE_PRLIMIT


120 
PyObjeù
 *

121 
	$psutž_lšux_´lim™
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

123 
pid
;

124 
»t
, 
»sourû
;

125 
¾im™
 
Þd
, 
Ãw
;

126 
¾im™
 *
Ãwp
 = 
NULL
;

127 
PyObjeù
 *
soá
 = 
NULL
;

128 
PyObjeù
 *
h¬d
 = 
NULL
;

130 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "li|OO", &
pid
, &
»sourû
, &
soá
, &
h¬d
)) {

131  
NULL
;

135 ià(
soá
 =ð
NULL
 && 
h¬d
 == NULL) {

136 
»t
 = 
	`´lim™
(
pid
, 
»sourû
, 
NULL
, &
Þd
);

137 ià(
»t
 == -1)

138  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

139 #ià
	`defšed
(
PSUTIL_HAVE_LONG_LONG
)

140 ià((
Þd
.
¾im_cur
) > ()) {

141  
	`Py_BuždV®ue
("LL",

142 (
PY_LONG_LONG
)
Þd
.
¾im_cur
,

143 (
PY_LONG_LONG
)
Þd
.
¾im_max
);

146  
	`Py_BuždV®ue
("Î", ()
Þd
.
¾im_cur
, ()Þd.
¾im_max
);

151 #ià
	`defšed
(
PSUTIL_HAVE_LARGEFILE_SUPPORT
)

152 
Ãw
.
¾im_cur
 = 
	`PyLÚg_AsLÚgLÚg
(
soá
);

153 ià(
Ãw
.
¾im_cur
 =ð(
¾im_t
è- 1 && 
	`PyE¼_Occu¼ed
())

154  
NULL
;

155 
Ãw
.
¾im_max
 = 
	`PyLÚg_AsLÚgLÚg
(
h¬d
);

156 ià(
Ãw
.
¾im_max
 =ð(
¾im_t
è- 1 && 
	`PyE¼_Occu¼ed
())

157  
NULL
;

159 
Ãw
.
¾im_cur
 = 
	`PyLÚg_AsLÚg
(
soá
);

160 ià(
Ãw
.
¾im_cur
 =ð(
¾im_t
è- 1 && 
	`PyE¼_Occu¼ed
())

161  
NULL
;

162 
Ãw
.
¾im_max
 = 
	`PyLÚg_AsLÚg
(
h¬d
);

163 ià(
Ãw
.
¾im_max
 =ð(
¾im_t
è- 1 && 
	`PyE¼_Occu¼ed
())

164  
NULL
;

166 
Ãwp
 = &
Ãw
;

167 
»t
 = 
	`´lim™
(
pid
, 
»sourû
, 
Ãwp
, &
Þd
);

168 ià(
»t
 == -1)

169  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

170 
	`Py_INCREF
(
Py_NÚe
);

171  
Py_NÚe
;

173 
	}
}

181 
PyObjeù
 *

182 
	$psutž_disk_·¹™iÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

184 
FILE
 *
fže
 = 
NULL
;

185 
mÁ’t
 *
’Œy
;

186 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

187 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

189 ià(
py_»Ži¡
 =ð
NULL
)

190  
NULL
;

193 
Py_BEGIN_ALLOW_THREADS


194 
fže
 = 
	`£tmÁ’t
(
MOUNTED
, "r");

195 
Py_END_ALLOW_THREADS


196 ià((
fže
 =ð0è|| (fž=ð
NULL
)) {

197 
	`PyE¼_S‘FromE¼noW™hFž’ame
(
PyExc_OSE¼Ü
, 
MOUNTED
);

198 
”rÜ
;

201 (
’Œy
 = 
	`g‘mÁ’t
(
fže
))) {

202 ià(
’Œy
 =ð
NULL
) {

203 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "getmntent() failed");

204 
”rÜ
;

206 
py_tu¶e
 = 
	`Py_BuždV®ue
("(ssss)",

207 
’Œy
->
mÁ_f¢ame
,

208 
’Œy
->
mÁ_dœ
,

209 
’Œy
->
mÁ_ty³
,

210 
’Œy
->
mÁ_Ýts
);

211 ià(! 
py_tu¶e
)

212 
”rÜ
;

213 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

214 
”rÜ
;

215 
	`Py_DECREF
(
py_tu¶e
);

217 
	`’dmÁ’t
(
fže
);

218  
py_»Ži¡
;

220 
”rÜ
:

221 ià(
fže
 !ð
NULL
)

222 
	`’dmÁ’t
(
fže
);

223 
	`Py_XDECREF
(
py_tu¶e
);

224 
	`Py_DECREF
(
py_»Ži¡
);

225  
NULL
;

226 
	}
}

232 
PyObjeù
 *

233 
	$psutž_lšux_sysšfo
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

235 
sysšfo
 
šfo
;

236 ià(
	`sysšfo
(&
šfo
) != 0) {

237  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

241  
	`Py_BuždV®ue
(

243 ()
šfo
.
tÙ®¿m
 * info.
mem_un™
,

244 ()
šfo
.
ä“¿m
 * info.
mem_un™
,

245 ()
šfo
.
bufã¼am
 * info.
mem_un™
,

246 ()
šfo
.
sh¬ed¿m
 * info.
mem_un™
,

247 ()
šfo
.
tÙ®sw­
 * info.
mem_un™
,

248 ()
šfo
.
ä“sw­
 * info.
mem_un™
);

249 
	}
}

255 
PyObjeù
 *

256 
	$psutž_´oc_ýu_affš™y_g‘
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

258 
mask
;

259 
Ën
 = (
mask
);

260 
pid
;

262 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
)) {

263  
NULL
;

265 ià(
	`sched_g‘affš™y
(
pid
, 
Ën
, (
ýu_£t_t
 *)&
mask
) < 0) {

266  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

268  
	`Py_BuždV®ue
("l", 
mask
);

269 
	}
}

275 
PyObjeù
 *

276 
	$psutž_´oc_ýu_affš™y_£t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

278 
ýu_£t_t
 
ýu_£t
;

279 
size_t
 
Ën
;

280 
pid
;

281 
i
, 
£q_Ën
;

282 
PyObjeù
 *
py_ýu_£t
;

283 
PyObjeù
 *
py_ýu_£q
 = 
NULL
;

285 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "lO", &
pid
, &
py_ýu_£t
)) {

286 
”rÜ
;

289 ià(!
	`PySequ’û_Check
(
py_ýu_£t
)) {

293 
	`PyE¼_FÜm©
(
PyExc_Ty³E¼Ü
, "sequence‡rgumentƒxpected");

294 
”rÜ
;

297 
py_ýu_£q
 = 
	`PySequ’û_Fa¡
(
py_ýu_£t
, "expected‡ sequence or integer");

298 ià(!
py_ýu_£q
) {

299 
”rÜ
;

301 
£q_Ën
 = 
	`PySequ’û_Fa¡_GET_SIZE
(
py_ýu_£q
);

302 
	`CPU_ZERO
(&
ýu_£t
);

303 
i
 = 0; i < 
£q_Ën
; i++) {

304 
PyObjeù
 *
™em
 = 
	`PySequ’û_Fa¡_GET_ITEM
(
py_ýu_£q
, 
i
);

305 #ià
PY_MAJOR_VERSION
 >= 3

306 
v®ue
 = 
	`PyLÚg_AsLÚg
(
™em
);

308 
v®ue
 = 
	`PyIÁ_AsLÚg
(
™em
);

310 ià(
v®ue
 =ð-1 && 
	`PyE¼_Occu¼ed
()) {

311 
”rÜ
;

313 
	`CPU_SET
(
v®ue
, &
ýu_£t
);

316 
Ën
 = (
ýu_£t
);

317 ià(
	`sched_£ffš™y
(
pid
, 
Ën
, &
ýu_£t
)) {

318 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

319 
”rÜ
;

322 
	`Py_DECREF
(
py_ýu_£q
);

323 
	`Py_INCREF
(
Py_NÚe
);

324  
Py_NÚe
;

326 
”rÜ
:

327 ià(
py_ýu_£q
 !ð
NULL
)

328 
	`Py_DECREF
(
py_ýu_£q
);

329  
NULL
;

330 
	}
}

336 
PyObjeù
 *

337 
	$psutž_u£rs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

339 
PyObjeù
 *
»t_li¡
 = 
	`PyLi¡_New
(0);

340 
PyObjeù
 *
tu¶e
 = 
NULL
;

341 
PyObjeù
 *
u£r_´oc
 = 
NULL
;

342 
utmp
 *
ut
;

344 ià(
»t_li¡
 =ð
NULL
)

345  
NULL
;

346 
	`£tu‹Á
();

347 
NULL
 !ð(
ut
 = 
	`g‘u‹Á
())) {

348 
tu¶e
 = 
NULL
;

349 
u£r_´oc
 = 
NULL
;

350 ià(
ut
->
ut_ty³
 =ð
USER_PROCESS
)

351 
u£r_´oc
 = 
Py_True
;

353 
u£r_´oc
 = 
Py_F®£
;

354 
tu¶e
 = 
	`Py_BuždV®ue
(

356 
ut
->
ut_u£r
,

357 
ut
->
ut_lše
,

358 
ut
->
ut_ho¡
,

359 ()
ut
->
ut_tv
.
tv_£c
,

360 
u£r_´oc


362 ià(! 
tu¶e
)

363 
”rÜ
;

364 ià(
	`PyLi¡_Aµ’d
(
»t_li¡
, 
tu¶e
))

365 
”rÜ
;

366 
	`Py_DECREF
(
tu¶e
);

368 
	`’du‹Á
();

369  
»t_li¡
;

371 
”rÜ
:

372 
	`Py_XDECREF
(
tu¶e
);

373 
	`Py_XDECREF
(
u£r_´oc
);

374 
	`Py_DECREF
(
»t_li¡
);

375 
	`’du‹Á
();

376  
NULL
;

377 
	}
}

383 
PyM‘hodDef


384 
	gPsutžM‘hods
[] =

388 #ià
PSUTIL_HAVE_IOPRIO


389 {"´oc_iÝrio_g‘", 
psutž_´oc_iÝrio_g‘
, 
METH_VARARGS
,

391 {"´oc_iÝrio_£t", 
psutž_´oc_iÝrio_£t
, 
METH_VARARGS
,

394 {"´oc_ýu_affš™y_g‘", 
psutž_´oc_ýu_affš™y_g‘
, 
METH_VARARGS
,

396 {"´oc_ýu_affš™y_£t", 
psutž_´oc_ýu_affš™y_£t
, 
METH_VARARGS
,

401 {"disk_·¹™iÚs", 
psutž_disk_·¹™iÚs
, 
METH_VARARGS
,

404 {"u£rs", 
psutž_u£rs
, 
METH_VARARGS
,

409 {"lšux_sysšfo", 
psutž_lšux_sysšfo
, 
METH_VARARGS
,

411 #ià
PSUTIL_HAVE_PRLIMIT


412 {"lšux_´lim™", 
psutž_lšux_´lim™
, 
METH_VARARGS
,

417 {
NULL
, NULL, 0, NULL}

420 
	smoduË_¡©e
 {

421 
PyObjeù
 *
	m”rÜ
;

424 #ià
PY_MAJOR_VERSION
 >= 3

425 

	#GETSTATE
(
m
è((
moduË_¡©e
*)
	`PyModuË_G‘S‹
(m))

	)

427 

	#GETSTATE
(
m
è(&
_¡©e
)

	)

430 #ià
PY_MAJOR_VERSION
 >= 3

433 
	$psutž_lšux_Œav”£
(
PyObjeù
 *
m
, 
vis™´oc
 
vis™
, *
¬g
) {

434 
	`Py_VISIT
(
	`GETSTATE
(
m
)->
”rÜ
);

436 
	}
}

439 
	$psutž_lšux_þ—r
(
PyObjeù
 *
m
) {

440 
	`Py_CLEAR
(
	`GETSTATE
(
m
)->
”rÜ
);

442 
	}
}

444 
PyModuËDef


445 
	gmoduËdef
 = {

446 
PyModuËDef_HEAD_INIT
,

448 
NULL
,

449 (
moduË_¡©e
),

450 
PsutžM‘hods
,

451 
NULL
,

452 
psutž_lšux_Œav”£
,

453 
psutž_lšux_þ—r
,

454 
NULL


457 

	#INITERROR
  
NULL


	)

459 
PyMODINIT_FUNC
 
	$PyIn™__psutž_lšux
()

462 

	#INITERROR
 

	)

464 
	$š™_psutž_lšux
()

467 #ià
PY_MAJOR_VERSION
 >= 3

468 
PyObjeù
 *
moduË
 = 
	`PyModuË_C»©e
(&
moduËdef
);

470 
PyObjeù
 *
moduË
 = 
	`Py_In™ModuË
("_psutž_lšux", 
PsutžM‘hods
);

474 #ià
PSUTIL_HAVE_PRLIMIT


475 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIM_INFINITY", 
RLIM_INFINITY
);

476 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_AS", 
RLIMIT_AS
);

477 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_CORE", 
RLIMIT_CORE
);

478 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_CPU", 
RLIMIT_CPU
);

479 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_DATA", 
RLIMIT_DATA
);

480 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_FSIZE", 
RLIMIT_FSIZE
);

481 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_LOCKS", 
RLIMIT_LOCKS
);

482 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_MEMLOCK", 
RLIMIT_MEMLOCK
);

483 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_NOFILE", 
RLIMIT_NOFILE
);

484 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_NPROC", 
RLIMIT_NPROC
);

485 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_RSS", 
RLIMIT_RSS
);

486 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_STACK", 
RLIMIT_STACK
);

487 #ifdeà
RLIMIT_MSGQUEUE


488 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_MSGQUEUE", 
RLIMIT_MSGQUEUE
);

490 #ifdeà
RLIMIT_NICE


491 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_NICE", 
RLIMIT_NICE
);

493 #ifdeà
RLIMIT_RTPRIO


494 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_RTPRIO", 
RLIMIT_RTPRIO
);

496 #ifdeà
RLIMIT_RTTIME


497 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_RTTIME", 
RLIMIT_RTTIME
);

499 #ifdeà
RLIMIT_SIGPENDING


500 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "RLIMIT_SIGPENDING", 
RLIMIT_SIGPENDING
);

504 ià(
moduË
 =ð
NULL
) {

505 
INITERROR
;

507 #ià
PY_MAJOR_VERSION
 >= 3

508  
moduË
;

510 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_linux.h

7 
	~<PythÚ.h
>

11 
PyObjeù
* 
psutž_´oc_ýu_affš™y_g‘
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

12 
PyObjeù
* 
psutž_´oc_ýu_affš™y_£t
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

13 
PyObjeù
* 
psutž_´oc_iÝrio_g‘
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

14 
PyObjeù
* 
psutž_´oc_iÝrio_g‘
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

18 
PyObjeù
* 
psutž_disk_·¹™iÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

19 
PyObjeù
* 
psutž_lšux_sysšfo
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

20 
PyObjeù
* 
psutž_u£rs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_osx.c

9 
	~<PythÚ.h
>

10 
	~<as£¹.h
>

11 
	~<Ӽo.h
>

12 
	~<¡dboÞ.h
>

13 
	~<¡dlib.h
>

14 
	~<¡dio.h
>

15 
	~<utmpx.h
>

16 
	~<sys/sysùl.h
>

17 
	~<sys/vmm‘”.h
>

18 
	~<lib´oc.h
>

19 
	~<sys/´oc_šfo.h
>

20 
	~<Ãtš‘/tý_fsm.h
>

21 
	~<¬·/š‘.h
>

22 
	~<Ãt/if_dl.h
>

23 
	~<pwd.h
>

25 
	~<mach/mach.h
>

26 
	~<mach/sk.h
>

27 
	~<mach/mach_š™.h
>

28 
	~<mach/ho¡_šfo.h
>

29 
	~<mach/mach_ho¡.h
>

30 
	~<mach/mach_Œ­s.h
>

31 
	~<mach/mach_vm.h
>

32 
	~<mach/sh¬ed_»giÚ.h
>

34 
	~<mach-o/lßd”.h
>

36 
	~<CÜeFound©iÚ/CÜeFound©iÚ.h
>

37 
	~<IOK™/IOK™Lib.h
>

38 
	~<IOK™/¡Üage/IOBlockStÜageDriv”.h
>

39 
	~<IOK™/¡Üage/IOMedŸ.h
>

40 
	~<IOK™/IOBSD.h
>

42 
	~"_psutž_osx.h
"

43 
	~"_psutž_commÚ.h
"

44 
	~"¬ch/osx/´oûss_šfo.h
"

51 
	$psutž_sys_vmšfo
(
vm_¡©i¡ics_d©a_t
 *
vm¡©
)

53 
k”n_»tuº_t
 
»t
;

54 
mach_msg_ty³_numb”_t
 
couÁ
 = (*
vm¡©
è/ (
š‹g”_t
);

55 
mach_pÜt_t
 
mpÜt
 = 
	`mach_ho¡_£lf
();

57 
»t
 = 
	`ho¡_¡©i¡ics
(
mpÜt
, 
HOST_VM_INFO
, (
ho¡_šfo_t
)
vm¡©
, &
couÁ
);

58 ià(
»t
 !ð
KERN_SUCCESS
) {

59 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

60 "ho¡_¡©i¡ics(èçžed: %s", 
	`mach_”rÜ_¡ršg
(
»t
));

63 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
mpÜt
);

65 
	}
}

71 
PyObjeù
 *

72 
	$psutž_pids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

74 
kšfo_´oc
 *
´oþi¡
 = 
NULL
;

75 
kšfo_´oc
 *
Üig_add»ss
 = 
NULL
;

76 
size_t
 
num_´oûs£s
;

77 
size_t
 
idx
;

78 
PyObjeù
 *
pid
 = 
NULL
;

79 
PyObjeù
 *
»Ži¡
 = 
	`PyLi¡_New
(0);

81 ià(
»Ži¡
 =ð
NULL
)

82  
NULL
;

84 ià(
	`psutž_g‘_´oc_li¡
(&
´oþi¡
, &
num_´oûs£s
) != 0) {

85 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

87 
”rÜ
;

90 ià(
num_´oûs£s
 > 0) {

92 
Üig_add»ss
 = 
´oþi¡
;

93 
idx
 = 0; idx < 
num_´oûs£s
; idx++) {

94 
pid
 = 
	`Py_BuždV®ue
("i", 
´oþi¡
->
kp_´oc
.
p_pid
);

95 ià(!
pid
)

96 
”rÜ
;

97 ià(
	`PyLi¡_Aµ’d
(
»Ži¡
, 
pid
))

98 
”rÜ
;

99 
	`Py_DECREF
(
pid
);

100 
´oþi¡
++;

102 
	`ä“
(
Üig_add»ss
);

104  
»Ži¡
;

106 
”rÜ
:

107 
	`Py_XDECREF
(
pid
);

108 
	`Py_DECREF
(
»Ži¡
);

109 ià(
Üig_add»ss
 !ð
NULL
)

110 
	`ä“
(
Üig_add»ss
);

111  
NULL
;

112 
	}
}

118 
PyObjeù
 *

119 
	$psutž_´oc_Çme
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

121 
pid
;

122 
kšfo_´oc
 
kp
;

123 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

124  
NULL
;

126 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

127  
NULL
;

129  
	`Py_BuždV®ue
("s", 
kp
.
kp_´oc
.
p_comm
);

130 
	}
}

136 
PyObjeù
 *

137 
	$psutž_´oc_cwd
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

139 
pid
;

140 
´oc_vnod•©hšfo
 
·thšfo
;

142 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

143  
NULL
;

146 ià(! 
	`psutž_´oc_pidšfo
(
pid
, 
PROC_PIDVNODEPATHINFO
, &
·thšfo
,

147 (
·thšfo
)))

149  
NULL
;

151  
	`Py_BuždV®ue
("s", 
·thšfo
.
pvi_cdœ
.
v_·th
);

152 
	}
}

158 
PyObjeù
 *

159 
	$psutž_´oc_exe
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

161 
pid
;

162 
buf
[
PATH_MAX
];

163 
»t
;

165 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

166  
NULL
;

168 
»t
 = 
	`´oc_pid·th
(
pid
, &
buf
, (buf));

169 ià(
»t
 == 0) {

170 ià(! 
	`psutž_pid_exi¡s
(
pid
)) {

171  
	`NoSuchProûss
();

174  
	`AcûssD’›d
();

177  
	`Py_BuždV®ue
("s", 
buf
);

178 
	}
}

184 
PyObjeù
 *

185 
	$psutž_´oc_cmdlše
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

187 
pid
;

188 
PyObjeù
 *
¬gli¡
 = 
NULL
;

190 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

191  
NULL
;

195 
¬gli¡
 = 
	`psutž_g‘_¬g_li¡
(
pid
);

196  
¬gli¡
;

197 
	}
}

203 
PyObjeù
 *

204 
	$psutž_´oc_µid
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

206 
pid
;

207 
kšfo_´oc
 
kp
;

208 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

209  
NULL
;

211 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

212  
NULL
;

214  
	`Py_BuždV®ue
("l", ()
kp
.
kp_•roc
.
e_µid
);

215 
	}
}

221 
PyObjeù
 *

222 
	$psutž_´oc_uids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

224 
pid
;

225 
kšfo_´oc
 
kp
;

226 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

227  
NULL
;

229 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

230  
NULL
;

232  
	`Py_BuždV®ue
("lll",

233 ()
kp
.
kp_•roc
.
e_püed
.
p_ruid
,

234 ()
kp
.
kp_•roc
.
e_uüed
.
ü_uid
,

235 ()
kp
.
kp_•roc
.
e_püed
.
p_svuid
);

236 
	}
}

242 
PyObjeù
 *

243 
	$psutž_´oc_gids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

245 
pid
;

246 
kšfo_´oc
 
kp
;

247 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

248  
NULL
;

250 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

251  
NULL
;

253  
	`Py_BuždV®ue
("lll",

254 ()
kp
.
kp_•roc
.
e_püed
.
p_rgid
,

255 ()
kp
.
kp_•roc
.
e_uüed
.
ü_groups
[0],

256 ()
kp
.
kp_•roc
.
e_püed
.
p_svgid
);

257 
	}
}

263 
PyObjeù
 *

264 
	$psutž_´oc_‰y_Ä
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

266 
pid
;

267 
kšfo_´oc
 
kp
;

268 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

269  
NULL
;

271 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

272  
NULL
;

274  
	`Py_BuždV®ue
("i", 
kp
.
kp_•roc
.
e_tdev
);

275 
	}
}

282 
PyObjeù
 *

283 
	$psutž_´oc_memÜy_m­s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

285 
buf
[
PATH_MAX
];

286 
addr_¡r
[34];

287 
³rms
[8];

288 
·gesize
 = 
	`g‘·gesize
();

289 
pid
;

290 
k”n_»tuº_t
 
”r
 = 
KERN_SUCCESS
;

291 
mach_pÜt_t
 
sk
 = 
MACH_PORT_NULL
;

292 
ušt32_t
 
d•th
 = 1;

293 
vm_add»ss_t
 
add»ss
 = 0;

294 
vm_size_t
 
size
 = 0;

296 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

297 
PyObjeù
 *
py_li¡
 = 
	`PyLi¡_New
(0);

299 ià(
py_li¡
 =ð
NULL
)

300  
NULL
;

302 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

303 
”rÜ
;

306 
”r
 = 
	`sk_fÜ_pid
(
	`mach_sk_£lf
(), 
pid
, &
sk
);

308 ià(
”r
 !ð
KERN_SUCCESS
) {

309 ià(! 
	`psutž_pid_exi¡s
(
pid
)) {

310 
	`NoSuchProûss
();

315 
	`AcûssD’›d
();

317 
”rÜ
;

321 
py_tu¶e
 = 
NULL
;

322 
vm_»giÚ_subm­_šfo_64
 
šfo
;

323 
mach_msg_ty³_numb”_t
 
couÁ
 = 
VM_REGION_SUBMAP_INFO_COUNT_64
;

325 
”r
 = 
	`vm_»giÚ_»cur£_64
(
sk
, &
add»ss
, &
size
, &
d•th
,

326 (
vm_»giÚ_šfo_64_t
)&
šfo
, &
couÁ
);

328 ià(
”r
 =ð
KERN_INVALID_ADDRESS
) {

332 ià(
šfo
.
is_subm­
) {

333 
d•th
++;

337 
	`mem£t
(
buf
, 0, (buf));

338 
	`mem£t
(
addr_¡r
, 0, (addr_str));

339 
	`mem£t
(
³rms
, 0, (perms));

341 
	`¥rštf
(
addr_¡r
, "%016lx-%016lx", 
add»ss
,‡dd»s + 
size
);

342 
	`¥rštf
(
³rms
, "%c%c%c/%c%c%c",

343 (
šfo
.
´ÙeùiÚ
 & 
VM_PROT_READ
) ? 'r' : '-',

344 (
šfo
.
´ÙeùiÚ
 & 
VM_PROT_WRITE
) ? 'w' : '-',

345 (
šfo
.
´ÙeùiÚ
 & 
VM_PROT_EXECUTE
) ? 'x' : '-',

346 (
šfo
.
max_´ÙeùiÚ
 & 
VM_PROT_READ
) ? 'r' : '-',

347 (
šfo
.
max_´ÙeùiÚ
 & 
VM_PROT_WRITE
) ? 'w' : '-',

348 (
šfo
.
max_´ÙeùiÚ
 & 
VM_PROT_EXECUTE
) ? 'x' : '-');

350 
”r
 = 
	`´oc_»giÚfž’ame
(
pid
, 
add»ss
, 
buf
, (buf));

352 ià(
šfo
.
sh¬e_mode
 =ð
SM_COW
 && info.
»f_couÁ
 == 1) {

354 
šfo
.
sh¬e_mode
 = 
SM_PRIVATE
;

357 ià(
	`¡¾’
(
buf
) == 0) {

358 
šfo
.
sh¬e_mode
) {

364 
SM_COW
:

365 
	`¡rýy
(
buf
, "[cow]");

367 
SM_PRIVATE
:

368 
	`¡rýy
(
buf
, "[prv]");

370 
SM_EMPTY
:

371 
	`¡rýy
(
buf
, "[nul]");

373 
SM_SHARED
:

374 
SM_TRUESHARED
:

375 
	`¡rýy
(
buf
, "[shm]");

377 
SM_PRIVATE_ALIASED
:

378 
	`¡rýy
(
buf
, "[ali]");

380 
SM_SHARED_ALIASED
:

381 
	`¡rýy
(
buf
, "[s/a]");

384 
	`¡rýy
(
buf
, "[???]");

388 
py_tu¶e
 = 
	`Py_BuždV®ue
(

390 
addr_¡r
,

391 
³rms
,

392 
buf
,

393 
šfo
.
·ges_»sid’t
 * 
·gesize
,

394 
šfo
.
·ges_sh¬ed_now_´iv©e
 * 
·gesize
,

395 
šfo
.
·ges_sw­³d_out
 * 
·gesize
,

396 
šfo
.
·ges_dœt›d
 * 
·gesize
,

397 
šfo
.
»f_couÁ
,

398 
šfo
.
shadow_d•th


400 ià(!
py_tu¶e
)

401 
”rÜ
;

402 ià(
	`PyLi¡_Aµ’d
(
py_li¡
, 
py_tu¶e
))

403 
”rÜ
;

404 
	`Py_DECREF
(
py_tu¶e
);

408 
add»ss
 +ð
size
;

411 ià(
sk
 !ð
MACH_PORT_NULL
)

412 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
sk
);

414  
py_li¡
;

416 
”rÜ
:

417 ià(
sk
 !ð
MACH_PORT_NULL
)

418 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
sk
);

419 
	`Py_XDECREF
(
py_tu¶e
);

420 
	`Py_DECREF
(
py_li¡
);

421  
NULL
;

422 
	}
}

429 
PyObjeù
 *

430 
	$psutž_ýu_couÁ_logiÿl
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

432 
mib
[2];

433 
nýu
;

434 
size_t
 
Ën
;

436 
mib
[0] = 
CTL_HW
;

437 
mib
[1] = 
HW_NCPU
;

438 
Ën
 = (
nýu
);

440 ià(
	`sysùl
(
mib
, 2, &
nýu
, &
Ën
, 
NULL
, 0) == -1) {

442 
	`Py_INCREF
(
Py_NÚe
);

443  
Py_NÚe
;

446  
	`Py_BuždV®ue
("i", 
nýu
);

448 
	}
}

454 
PyObjeù
 *

455 
	$psutž_ýu_couÁ_phys
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

457 
num
;

458 
size_t
 
size
 = ();

459 ià(
	`sysùlbyÇme
("hw.physiÿlýu", &
num
, &
size
, 
NULL
, 0)) {

461 
	`Py_INCREF
(
Py_NÚe
);

462  
Py_NÚe
;

464  
	`Py_BuždV®ue
("i", 
num
);

465 
	}
}

468 

	#TV2DOUBLE
(
t
è(Ñ).
tv_£c
 + (t).
tv_u£c
 / 1000000.0)

	)

473 
PyObjeù
 *

474 
	$psutž_´oc_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

476 
pid
;

477 
´oc_skšfo
 
±i
;

478 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

479  
NULL
;

481 ià(! 
	`psutž_´oc_pidšfo
(
pid
, 
PROC_PIDTASKINFO
, &
±i
, (pti))) {

482  
NULL
;

484  
	`Py_BuždV®ue
("(dd)",

485 ()
±i
.
±i_tÙ®_u£r
 / 1000000000.0,

486 ()
±i
.
±i_tÙ®_sy¡em
 / 1000000000.0);

487 
	}
}

494 
PyObjeù
 *

495 
	$psutž_´oc_ü—‹_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

497 
pid
;

498 
kšfo_´oc
 
kp
;

499 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

500  
NULL
;

502 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

503  
NULL
;

505  
	`Py_BuždV®ue
("d", 
	`TV2DOUBLE
(
kp
.
kp_´oc
.
p_¡¬‰ime
));

506 
	}
}

512 
PyObjeù
 *

513 
	$psutž_´oc_memÜy_šfo
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

515 
pid
;

516 
´oc_skšfo
 
±i
;

517 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

518  
NULL
;

520 ià(! 
	`psutž_´oc_pidšfo
(
pid
, 
PROC_PIDTASKINFO
, &
±i
, (pti))) {

521  
NULL
;

529  
	`Py_BuždV®ue
(

531 
±i
.
±i_»sid’t_size
,

532 
±i
.
±i_vœtu®_size
,

533 
±i
.
±i_çuÉs
,

534 
±i
.
±i_·gešs


536 
	}
}

542 
PyObjeù
 *

543 
	$psutž_´oc_num_th»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

545 
pid
;

546 
´oc_skšfo
 
±i
;

547 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

548  
NULL
;

550 ià(! 
	`psutž_´oc_pidšfo
(
pid
, 
PROC_PIDTASKINFO
, &
±i
, (pti))) {

551  
NULL
;

553  
	`Py_BuždV®ue
("k", 
±i
.
±i_th»adnum
);

554 
	}
}

560 
PyObjeù
 *

561 
	$psutž_´oc_num_ùx_sw™ches
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

563 
pid
;

564 
´oc_skšfo
 
±i
;

565 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

566  
NULL
;

568 ià(! 
	`psutž_´oc_pidšfo
(
pid
, 
PROC_PIDTASKINFO
, &
±i
, (pti))) {

569  
NULL
;

574  
	`Py_BuždV®ue
("ki", 
±i
.
±i_csw
, 0);

575 
	}
}

581 
PyObjeù
 *

582 
	$psutž_vœtu®_mem
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

585 
mib
[2];

586 
ušt64_t
 
tÙ®
;

587 
size_t
 
Ën
 = (
tÙ®
);

588 
vm_¡©i¡ics_d©a_t
 
vm
;

589 
·gesize
 = 
	`g‘·gesize
();

592 
mib
[0] = 
CTL_HW
;

593 
mib
[1] = 
HW_MEMSIZE
;

594 ià(
	`sysùl
(
mib
, 2, &
tÙ®
, &
Ën
, 
NULL
, 0)) {

595 ià(
Ӽo
 != 0)

596 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

598 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "sysctl(HW_MEMSIZE) failed");

599  
NULL
;

603 ià(!
	`psutž_sys_vmšfo
(&
vm
)) {

604  
NULL
;

607  
	`Py_BuždV®ue
(

609 
tÙ®
,

610 (è
vm
.
aùive_couÁ
 * 
·gesize
,

611 (è
vm
.
šaùive_couÁ
 * 
·gesize
,

612 (è
vm
.
wœe_couÁ
 * 
·gesize
,

613 (è
vm
.
ä“_couÁ
 * 
·gesize


615 
	}
}

621 
PyObjeù
 *

622 
	$psutž_sw­_mem
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

624 
mib
[2];

625 
size_t
 
size
;

626 
xsw_u§ge
 
tÙ®s
;

627 
vm_¡©i¡ics_d©a_t
 
vm¡©
;

628 
·gesize
 = 
	`g‘·gesize
();

630 
mib
[0] = 
CTL_VM
;

631 
mib
[1] = 
VM_SWAPUSAGE
;

632 
size
 = (
tÙ®s
);

633 ià(
	`sysùl
(
mib
, 2, &
tÙ®s
, &
size
, 
NULL
, 0) == -1) {

634 ià(
Ӽo
 != 0)

635 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

637 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "sysctl(VM_SWAPUSAGE) failed");

638  
NULL
;

640 ià(!
	`psutž_sys_vmšfo
(&
vm¡©
)) {

641  
NULL
;

644  
	`Py_BuždV®ue
(

646 
tÙ®s
.
xsu_tÙ®
,

647 
tÙ®s
.
xsu_u£d
,

648 
tÙ®s
.
xsu_avaž
,

649 ()
vm¡©
.
·gešs
 * 
·gesize
,

650 ()
vm¡©
.
·geouts
 * 
·gesize
);

651 
	}
}

657 
PyObjeù
 *

658 
	$psutž_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

660 
mach_msg_ty³_numb”_t
 
couÁ
 = 
HOST_CPU_LOAD_INFO_COUNT
;

661 
k”n_»tuº_t
 
”rÜ
;

662 
ho¡_ýu_lßd_šfo_d©a_t
 
r_lßd
;

664 
mach_pÜt_t
 
ho¡_pÜt
 = 
	`mach_ho¡_£lf
();

665 
”rÜ
 = 
	`ho¡_¡©i¡ics
(
ho¡_pÜt
, 
HOST_CPU_LOAD_INFO
,

666 (
ho¡_šfo_t
)&
r_lßd
, &
couÁ
);

667 ià(
”rÜ
 !ð
KERN_SUCCESS
) {

668  
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

670 
	`mach_”rÜ_¡ršg
(
”rÜ
));

672 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
ho¡_pÜt
);

674  
	`Py_BuždV®ue
(

676 ()
r_lßd
.
ýu_ticks
[
CPU_STATE_USER
] / 
CLK_TCK
,

677 ()
r_lßd
.
ýu_ticks
[
CPU_STATE_NICE
] / 
CLK_TCK
,

678 ()
r_lßd
.
ýu_ticks
[
CPU_STATE_SYSTEM
] / 
CLK_TCK
,

679 ()
r_lßd
.
ýu_ticks
[
CPU_STATE_IDLE
] / 
CLK_TCK


681 
	}
}

687 
PyObjeù
 *

688 
	$psutž_³r_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

690 
Çtu¿l_t
 
ýu_couÁ
;

691 
´oûssÜ_šfo_¬¿y_t
 
šfo_¬¿y
;

692 
mach_msg_ty³_numb”_t
 
šfo_couÁ
;

693 
k”n_»tuº_t
 
”rÜ
;

694 
´oûssÜ_ýu_lßd_šfo_d©a_t
 *
ýu_lßd_šfo
 = 
NULL
;

695 
i
, 
»t
;

696 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

697 
PyObjeù
 *
py_ýutime
 = 
NULL
;

699 ià(
py_»Ži¡
 =ð
NULL
)

700  
NULL
;

702 
mach_pÜt_t
 
ho¡_pÜt
 = 
	`mach_ho¡_£lf
();

703 
”rÜ
 = 
	`ho¡_´oûssÜ_šfo
(
ho¡_pÜt
, 
PROCESSOR_CPU_LOAD_INFO
,

704 &
ýu_couÁ
, &
šfo_¬¿y
, &
šfo_couÁ
);

705 ià(
”rÜ
 !ð
KERN_SUCCESS
) {

706 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "Error in host_processor_info(): %s",

707 
	`mach_”rÜ_¡ršg
(
”rÜ
));

708 
”rÜ
;

710 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
ho¡_pÜt
);

712 
ýu_lßd_šfo
 = (
´oûssÜ_ýu_lßd_šfo_d©a_t
 *è
šfo_¬¿y
;

714 
i
 = 0; i < 
ýu_couÁ
; i++) {

715 
py_ýutime
 = 
	`Py_BuždV®ue
(

717 ()
ýu_lßd_šfo
[
i
].
ýu_ticks
[
CPU_STATE_USER
] / 
CLK_TCK
,

718 ()
ýu_lßd_šfo
[
i
].
ýu_ticks
[
CPU_STATE_NICE
] / 
CLK_TCK
,

719 ()
ýu_lßd_šfo
[
i
].
ýu_ticks
[
CPU_STATE_SYSTEM
] / 
CLK_TCK
,

720 ()
ýu_lßd_šfo
[
i
].
ýu_ticks
[
CPU_STATE_IDLE
] / 
CLK_TCK


722 ià(!
py_ýutime
)

723 
”rÜ
;

724 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_ýutime
))

725 
”rÜ
;

726 
	`Py_DECREF
(
py_ýutime
);

729 
»t
 = 
	`vm_d—Îoÿ‹
(
	`mach_sk_£lf
(), (
vm_add»ss_t
)
šfo_¬¿y
,

730 
šfo_couÁ
 * ());

731 ià(
»t
 !ð
KERN_SUCCESS
) {

732 
	`PyE¼_W¬nEx
(
PyExc_RuÁimeW¬nšg
, "vm_deallocate() failed", 2);

734  
py_»Ži¡
;

736 
”rÜ
:

737 
	`Py_XDECREF
(
py_ýutime
);

738 
	`Py_DECREF
(
py_»Ži¡
);

739 ià(
ýu_lßd_šfo
 !ð
NULL
) {

740 
»t
 = 
	`vm_d—Îoÿ‹
(
	`mach_sk_£lf
(), (
vm_add»ss_t
)
šfo_¬¿y
,

741 
šfo_couÁ
 * ());

742 ià(
»t
 !ð
KERN_SUCCESS
) {

743 
	`PyE¼_W¬nEx
(
PyExc_RuÁimeW¬nšg
, "vm_deallocate() failed", 2);

746  
NULL
;

747 
	}
}

754 
PyObjeù
 *

755 
	$psutž_boÙ_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

758 
»que¡
[2] = { 
CTL_KERN
, 
KERN_BOOTTIME
 };

759 
timev®
 
»suÉ
;

760 
size_t
 
»suÉ_Ën
 =  
»suÉ
;

761 
time_t
 
boÙ_time
 = 0;

763 ià(
	`sysùl
(
»que¡
, 2, &
»suÉ
, &
»suÉ_Ën
, 
NULL
, 0) == -1) {

764 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

765  
NULL
;

767 
boÙ_time
 = 
»suÉ
.
tv_£c
;

768  
	`Py_BuždV®ue
("f", ()
boÙ_time
);

769 
	}
}

776 
PyObjeù
 *

777 
	$psutž_disk_·¹™iÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

779 
num
;

780 
i
;

781 
Ën
;

782 
ušt64_t
 
æags
;

783 
Ýts
[400];

784 
¡©fs
 *
fs
 = 
NULL
;

785 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

786 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

788 ià(
py_»Ži¡
 =ð
NULL
)

789  
NULL
;

792 
Py_BEGIN_ALLOW_THREADS


793 
num
 = 
	`g‘fs¡©
(
NULL
, 0, 
MNT_NOWAIT
);

794 
Py_END_ALLOW_THREADS


795 ià(
num
 == -1) {

796 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

797 
”rÜ
;

800 
Ën
 = (*
fs
è* 
num
;

801 
fs
 = 
	`m®loc
(
Ën
);

802 ià(
fs
 =ð
NULL
) {

803 
	`PyE¼_NoMemÜy
();

804 
”rÜ
;

807 
Py_BEGIN_ALLOW_THREADS


808 
num
 = 
	`g‘fs¡©
(
fs
, 
Ën
, 
MNT_NOWAIT
);

809 
Py_END_ALLOW_THREADS


810 ià(
num
 == -1) {

811 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

812 
”rÜ
;

815 
i
 = 0; i < 
num
; i++) {

816 
Ýts
[0] = 0;

817 
æags
 = 
fs
[
i
].
f_æags
;

820 ià(
æags
 & 
MNT_RDONLY
)

821 
	`¡¾ÿt
(
Ýts
, "ro", (opts));

823 
	`¡¾ÿt
(
Ýts
, "rw", (opts));

824 ià(
æags
 & 
MNT_SYNCHRONOUS
)

825 
	`¡¾ÿt
(
Ýts
, ",sync", (opts));

826 ià(
æags
 & 
MNT_NOEXEC
)

827 
	`¡¾ÿt
(
Ýts
, ",noexec", (opts));

828 ià(
æags
 & 
MNT_NOSUID
)

829 
	`¡¾ÿt
(
Ýts
, ",nosuid", (opts));

830 ià(
æags
 & 
MNT_UNION
)

831 
	`¡¾ÿt
(
Ýts
, ",union", (opts));

832 ià(
æags
 & 
MNT_ASYNC
)

833 
	`¡¾ÿt
(
Ýts
, ",async", (opts));

834 ià(
æags
 & 
MNT_EXPORTED
)

835 
	`¡¾ÿt
(
Ýts
, ",exported", (opts));

836 ià(
æags
 & 
MNT_QUARANTINE
)

837 
	`¡¾ÿt
(
Ýts
, ",quarantine", (opts));

838 ià(
æags
 & 
MNT_LOCAL
)

839 
	`¡¾ÿt
(
Ýts
, ",local", (opts));

840 ià(
æags
 & 
MNT_QUOTA
)

841 
	`¡¾ÿt
(
Ýts
, ",quota", (opts));

842 ià(
æags
 & 
MNT_ROOTFS
)

843 
	`¡¾ÿt
(
Ýts
, ",rootfs", (opts));

844 ià(
æags
 & 
MNT_DOVOLFS
)

845 
	`¡¾ÿt
(
Ýts
, ",dovolfs", (opts));

846 ià(
æags
 & 
MNT_DONTBROWSE
)

847 
	`¡¾ÿt
(
Ýts
, ",dontbrowse", (opts));

848 ià(
æags
 & 
MNT_IGNORE_OWNERSHIP
)

849 
	`¡¾ÿt
(
Ýts
, ",ignore-ownership", (opts));

850 ià(
æags
 & 
MNT_AUTOMOUNTED
)

851 
	`¡¾ÿt
(
Ýts
, ",automounted", (opts));

852 ià(
æags
 & 
MNT_JOURNALED
)

853 
	`¡¾ÿt
(
Ýts
, ",journaled", (opts));

854 ià(
æags
 & 
MNT_NOUSERXATTR
)

855 
	`¡¾ÿt
(
Ýts
, ",nouserxattr", (opts));

856 ià(
æags
 & 
MNT_DEFWRITE
)

857 
	`¡¾ÿt
(
Ýts
, ",defwrite", (opts));

858 ià(
æags
 & 
MNT_MULTILABEL
)

859 
	`¡¾ÿt
(
Ýts
, ",multilabel", (opts));

860 ià(
æags
 & 
MNT_NOATIME
)

861 
	`¡¾ÿt
(
Ýts
, ",noatime", (opts));

862 ià(
æags
 & 
MNT_UPDATE
)

863 
	`¡¾ÿt
(
Ýts
, ",update", (opts));

864 ià(
æags
 & 
MNT_RELOAD
)

865 
	`¡¾ÿt
(
Ýts
, ",reload", (opts));

866 ià(
æags
 & 
MNT_FORCE
)

867 
	`¡¾ÿt
(
Ýts
, ",force", (opts));

868 ià(
æags
 & 
MNT_CMDFLAGS
)

869 
	`¡¾ÿt
(
Ýts
, ",cmdflags", (opts));

871 
py_tu¶e
 = 
	`Py_BuždV®ue
(

872 "(ssss)", 
fs
[
i
].
f_mÁäomÇme
,

873 
fs
[
i
].
f_mÁÚÇme
,

874 
fs
[
i
].
f_f¡y³Çme
,

875 
Ýts
);

876 ià(!
py_tu¶e
)

877 
”rÜ
;

878 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

879 
”rÜ
;

880 
	`Py_DECREF
(
py_tu¶e
);

883 
	`ä“
(
fs
);

884  
py_»Ži¡
;

886 
”rÜ
:

887 
	`Py_XDECREF
(
py_tu¶e
);

888 
	`Py_DECREF
(
py_»Ži¡
);

889 ià(
fs
 !ð
NULL
)

890 
	`ä“
(
fs
);

891  
NULL
;

892 
	}
}

898 
PyObjeù
 *

899 
	$psutž_´oc_¡©us
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

901 
pid
;

902 
kšfo_´oc
 
kp
;

903 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

904  
NULL
;

906 ià(
	`psutž_g‘_kšfo_´oc
(
pid
, &
kp
) == -1) {

907  
NULL
;

909  
	`Py_BuždV®ue
("i", ()
kp
.
kp_´oc
.
p_¡©
);

910 
	}
}

916 
PyObjeù
 *

917 
	$psutž_´oc_th»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

919 
pid
;

920 
”r
, 
j
, 
»t
;

921 
k”n_»tuº_t
 
kr
;

922 
šfo_couÁ
 = 
TASK_BASIC_INFO_COUNT
;

923 
mach_pÜt_t
 
sk
 = 
MACH_PORT_NULL
;

924 
sk_basic_šfo
 
sks_šfo
;

925 
th»ad_aù_pÜt_¬¿y_t
 
th»ad_li¡
 = 
NULL
;

926 
th»ad_šfo_d©a_t
 
thšfo_basic
;

927 
th»ad_basic_šfo_t
 
basic_šfo_th
;

928 
mach_msg_ty³_numb”_t
 
th»ad_couÁ
, 
th»ad_šfo_couÁ
;

930 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

931 
PyObjeù
 *
pyTu¶e
 = 
NULL
;

933 ià(
»tLi¡
 =ð
NULL
)

934  
NULL
;

937 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

938 
”rÜ
;

942 
”r
 = 
	`sk_fÜ_pid
(
	`mach_sk_£lf
(), 
pid
, &
sk
);

943 ià(
”r
 !ð
KERN_SUCCESS
) {

944 ià(! 
	`psutž_pid_exi¡s
(
pid
)) {

945 
	`NoSuchProûss
();

948 
	`AcûssD’›d
();

950 
”rÜ
;

953 
šfo_couÁ
 = 
TASK_BASIC_INFO_COUNT
;

954 
”r
 = 
	`sk_šfo
(
sk
, 
TASK_BASIC_INFO
, (
sk_šfo_t
)&
sks_šfo
,

955 &
šfo_couÁ
);

956 ià(
”r
 !ð
KERN_SUCCESS
) {

958 ià(
”r
 == 4) {

959 
	`AcûssD’›d
();

963 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

966 
”rÜ
;

969 
”r
 = 
	`sk_th»ads
(
sk
, &
th»ad_li¡
, &
th»ad_couÁ
);

970 ià(
”r
 !ð
KERN_SUCCESS
) {

971 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "task_threads() failed");

972 
”rÜ
;

975 
j
 = 0; j < 
th»ad_couÁ
; j++) {

976 
pyTu¶e
 = 
NULL
;

977 
th»ad_šfo_couÁ
 = 
THREAD_INFO_MAX
;

978 
kr
 = 
	`th»ad_šfo
(
th»ad_li¡
[
j
], 
THREAD_BASIC_INFO
,

979 (
th»ad_šfo_t
)
thšfo_basic
, &
th»ad_šfo_couÁ
);

980 ià(
kr
 !ð
KERN_SUCCESS
) {

981 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

983 
”rÜ
;

986 
basic_šfo_th
 = (
th»ad_basic_šfo_t
)
thšfo_basic
;

987 
pyTu¶e
 = 
	`Py_BuždV®ue
(

989 
j
 + 1,

990 ()
basic_šfo_th
->
u£r_time
.
miüo£cÚds
 / 1000000.0,

991 ()
basic_šfo_th
->
sy¡em_time
.
miüo£cÚds
 / 1000000.0

993 ià(!
pyTu¶e
)

994 
”rÜ
;

995 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
pyTu¶e
))

996 
”rÜ
;

997 
	`Py_DECREF
(
pyTu¶e
);

1000 
»t
 = 
	`vm_d—Îoÿ‹
(
sk
, (
vm_add»ss_t
)
th»ad_li¡
,

1001 
th»ad_couÁ
 * ());

1002 ià(
»t
 !ð
KERN_SUCCESS
) {

1003 
	`PyE¼_W¬nEx
(
PyExc_RuÁimeW¬nšg
, "vm_deallocate() failed", 2);

1006 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
sk
);

1008  
»tLi¡
;

1010 
”rÜ
:

1011 ià(
sk
 !ð
MACH_PORT_NULL
)

1012 
	`mach_pÜt_d—Îoÿ‹
(
	`mach_sk_£lf
(), 
sk
);

1013 
	`Py_XDECREF
(
pyTu¶e
);

1014 
	`Py_DECREF
(
»tLi¡
);

1015 ià(
th»ad_li¡
 !ð
NULL
) {

1016 
»t
 = 
	`vm_d—Îoÿ‹
(
sk
, (
vm_add»ss_t
)
th»ad_li¡
,

1017 
th»ad_couÁ
 * ());

1018 ià(
»t
 !ð
KERN_SUCCESS
) {

1019 
	`PyE¼_W¬nEx
(
PyExc_RuÁimeW¬nšg
, "vm_deallocate() failed", 2);

1022  
NULL
;

1023 
	}
}

1032 
PyObjeù
 *

1033 
	$psutž_´oc_Ý’_fžes
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1035 
pid
;

1036 
pidšfo_»suÉ
;

1037 
™”©iÚs
;

1038 
i
;

1039 
nb
;

1041 
´oc_fdšfo
 *
fds_poš‹r
 = 
NULL
;

1042 
´oc_fdšfo
 *
fdp_poš‹r
;

1043 
vnode_fdšfow™h·th
 
vi
;

1045 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

1046 
PyObjeù
 *
tu¶e
 = 
NULL
;

1048 ià(
»tLi¡
 =ð
NULL
)

1049  
NULL
;

1051 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1052 
”rÜ
;

1055 
pidšfo_»suÉ
 = 
	`´oc_pidšfo
(
pid
, 
PROC_PIDLISTFDS
, 0, 
NULL
, 0);

1056 ià(
pidšfo_»suÉ
 <= 0) {

1058 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

1060 
”rÜ
;

1063 
fds_poš‹r
 = 
	`m®loc
(
pidšfo_»suÉ
);

1064 ià(
fds_poš‹r
 =ð
NULL
) {

1065 
	`PyE¼_NoMemÜy
();

1066 
”rÜ
;

1068 
pidšfo_»suÉ
 = 
	`´oc_pidšfo
(
pid
, 
PROC_PIDLISTFDS
, 0, 
fds_poš‹r
,

1069 
pidšfo_»suÉ
);

1070 ià(
pidšfo_»suÉ
 <= 0) {

1072 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

1074 
”rÜ
;

1077 
™”©iÚs
 = (
pidšfo_»suÉ
 / 
PROC_PIDLISTFD_SIZE
);

1079 
i
 = 0; i < 
™”©iÚs
; i++) {

1080 
tu¶e
 = 
NULL
;

1081 
fdp_poš‹r
 = &
fds_poš‹r
[
i
];

1083 ià(
fdp_poš‹r
->
´oc_fdty³
 =ð
PROX_FDTYPE_VNODE
)

1085 
nb
 = 
	`´oc_pidfdšfo
(
pid
,

1086 
fdp_poš‹r
->
´oc_fd
,

1087 
PROC_PIDFDVNODEPATHINFO
,

1088 &
vi
,

1089 (
vi
));

1092 ià(
nb
 <= 0) {

1093 ià((
Ӽo
 =ð
ENOENT
è|| (”ºØ=ð
EBADF
)) {

1099 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

1101 
”rÜ
;

1103 ià(
nb
 < (
vi
)) {

1104 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

1107 
”rÜ
;

1112 
tu¶e
 = 
	`Py_BuždV®ue
("(si)",

1113 
vi
.
pv
.
v_·th
,

1114 ()
fdp_poš‹r
->
´oc_fd
);

1115 ià(!
tu¶e
)

1116 
”rÜ
;

1117 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
tu¶e
))

1118 
”rÜ
;

1119 
	`Py_DECREF
(
tu¶e
);

1124 
	`ä“
(
fds_poš‹r
);

1125  
»tLi¡
;

1127 
”rÜ
:

1128 
	`Py_XDECREF
(
tu¶e
);

1129 
	`Py_DECREF
(
»tLi¡
);

1130 ià(
fds_poš‹r
 !ð
NULL
) {

1131 
	`ä“
(
fds_poš‹r
);

1133 ià(
Ӽo
 != 0) {

1134  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1136 ià(! 
	`psutž_pid_exi¡s
(
pid
)) {

1137  
	`NoSuchProûss
();

1141  
NULL
;

1143 
	}
}

1147 
	gPSUTIL_CONN_NONE
 = 128;

1155 
PyObjeù
 *

1156 
	$psutž_´oc_cÚÃùiÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1158 
pid
;

1159 
pidšfo_»suÉ
;

1160 
™”©iÚs
;

1161 
i
;

1162 
nb
;

1164 
´oc_fdšfo
 *
fds_poš‹r
 = 
NULL
;

1165 
´oc_fdšfo
 *
fdp_poš‹r
;

1166 
sock‘_fdšfo
 
si
;

1168 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

1169 
PyObjeù
 *
tu¶e
 = 
NULL
;

1170 
PyObjeù
 *
Ïddr
 = 
NULL
;

1171 
PyObjeù
 *
¿ddr
 = 
NULL
;

1172 
PyObjeù
 *
af_fž‹r
 = 
NULL
;

1173 
PyObjeù
 *
ty³_fž‹r
 = 
NULL
;

1175 ià(
»tLi¡
 =ð
NULL
)

1176  
NULL
;

1178 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lOO", &
pid
, &
af_fž‹r
, &
ty³_fž‹r
)) {

1179 
”rÜ
;

1182 ià(!
	`PySequ’û_Check
(
af_fž‹r
è|| !PySequ’û_Check(
ty³_fž‹r
)) {

1183 
	`PyE¼_S‘SŒšg
(
PyExc_Ty³E¼Ü
, "arg 2 or 3 is‚ot‡ sequence");

1184 
”rÜ
;

1187 ià(
pid
 == 0) {

1188  
»tLi¡
;

1191 
pidšfo_»suÉ
 = 
	`´oc_pidšfo
(
pid
, 
PROC_PIDLISTFDS
, 0, 
NULL
, 0);

1192 ià(
pidšfo_»suÉ
 <= 0) {

1193 
”rÜ
;

1196 
fds_poš‹r
 = 
	`m®loc
(
pidšfo_»suÉ
);

1197 ià(
fds_poš‹r
 =ð
NULL
) {

1198 
	`PyE¼_NoMemÜy
();

1199 
”rÜ
;

1201 
pidšfo_»suÉ
 = 
	`´oc_pidšfo
(
pid
, 
PROC_PIDLISTFDS
, 0, 
fds_poš‹r
,

1202 
pidšfo_»suÉ
);

1204 ià(
pidšfo_»suÉ
 <= 0) {

1205 
”rÜ
;

1208 
™”©iÚs
 = (
pidšfo_»suÉ
 / 
PROC_PIDLISTFD_SIZE
);

1210 
i
 = 0; i < 
™”©iÚs
; i++) {

1211 
tu¶e
 = 
NULL
;

1212 
Ïddr
 = 
NULL
;

1213 
¿ddr
 = 
NULL
;

1214 
Ӽo
 = 0;

1215 
fdp_poš‹r
 = &
fds_poš‹r
[
i
];

1217 ià(
fdp_poš‹r
->
´oc_fdty³
 =ð
PROX_FDTYPE_SOCKET
)

1219 
nb
 = 
	`´oc_pidfdšfo
(
pid
, 
fdp_poš‹r
->
´oc_fd
,

1220 
PROC_PIDFDSOCKETINFO
, &
si
, (si));

1223 ià(
nb
 <= 0) {

1224 ià(
Ӽo
 =ð
EBADF
) {

1228 ià(
Ӽo
 != 0) {

1229 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1232 
	`PyE¼_FÜm©
(

1233 
PyExc_RuÁimeE¼Ü
,

1236 
”rÜ
;

1238 ià(
nb
 < (
si
)) {

1239 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

1242 
”rÜ
;

1247 
fd
, 
çmžy
, 
ty³
, 
ÍÜt
, 
½Üt
, 
¡©e
;

1248 
l
[200], 
r
[200];

1249 
š£q
;

1250 
PyObjeù
 *
_çmžy
;

1251 
PyObjeù
 *
_ty³
;

1253 
fd
 = ()
fdp_poš‹r
->
´oc_fd
;

1254 
çmžy
 = 
si
.
psi
.
soi_çmžy
;

1255 
ty³
 = 
si
.
psi
.
soi_ty³
;

1258 
_çmžy
 = 
	`PyLÚg_FromLÚg
(()
çmžy
);

1259 
š£q
 = 
	`PySequ’û_Cڏšs
(
af_fž‹r
, 
_çmžy
);

1260 
	`Py_DECREF
(
_çmžy
);

1261 ià(
š£q
 == 0) {

1264 
_ty³
 = 
	`PyLÚg_FromLÚg
(()
ty³
);

1265 
š£q
 = 
	`PySequ’û_Cڏšs
(
ty³_fž‹r
, 
_ty³
);

1266 
	`Py_DECREF
(
_ty³
);

1267 ià(
š£q
 == 0) {

1271 ià(
Ӽo
 != 0) {

1272 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1273 
”rÜ
;

1276 ià((
çmžy
 =ð
AF_INET
è|| (çmžy =ð
AF_INET6
)) {

1277 ià(
çmžy
 =ð
AF_INET
) {

1278 
	`š‘_ÁÝ
(
AF_INET
,

1279 &
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_ši
. \

1280 
šsi_Ïddr
.
ša_46
.
i46a_addr4
,

1281 
l
,

1282 (
l
));

1283 
	`š‘_ÁÝ
(
AF_INET
,

1284 &
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_ši
.
šsi_çddr
. \

1285 
ša_46
.
i46a_addr4
,

1286 
r
,

1287 (
r
));

1290 
	`š‘_ÁÝ
(
AF_INET6
,

1291 &
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_ši
. \

1292 
šsi_Ïddr
.
ša_6
,

1293 
l
, (lip));

1294 
	`š‘_ÁÝ
(
AF_INET6
,

1295 &
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_ši
. \

1296 
šsi_çddr
.
ša_6
,

1297 
r
, (rip));

1301 ià(
Ӽo
 != 0) {

1302 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1303 
”rÜ
;

1306 
ÍÜt
 = 
	`Áohs
(
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_ši
.
šsi_ÍÜt
);

1307 
½Üt
 = 
	`Áohs
(
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_ši
.
šsi_åÜt
);

1308 ià(
ty³
 =ð
SOCK_STREAM
) {

1309 
¡©e
 = ()
si
.
psi
.
soi_´Ùo
.
´i_tý
.
týsi_¡©e
;

1312 
¡©e
 = 
PSUTIL_CONN_NONE
;

1315 
Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

1316 ià(!
Ïddr
)

1317 
”rÜ
;

1318 ià(
½Üt
 != 0) {

1319 
¿ddr
 = 
	`Py_BuždV®ue
("(si)", 
r
, 
½Üt
);

1322 
¿ddr
 = 
	`Py_BuždV®ue
("()");

1324 ià(!
¿ddr
)

1325 
”rÜ
;

1328 
tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNi)", 
fd
, 
çmžy
, 
ty³
, 
Ïddr
,

1329 
¿ddr
, 
¡©e
);

1330 ià(!
tu¶e
)

1331 
”rÜ
;

1332 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
tu¶e
))

1333 
”rÜ
;

1334 
	`Py_DECREF
(
tu¶e
);

1336 ià(
çmžy
 =ð
AF_UNIX
) {

1338 
tu¶e
 = 
	`Py_BuždV®ue
(

1340 
fd
, 
çmžy
, 
ty³
,

1341 
si
.
psi
.
soi_´Ùo
.
´i_un
.
unsi_addr
.
ua_sun
.
sun_·th
,

1342 
si
.
psi
.
soi_´Ùo
.
´i_un
.
unsi_ÿddr
.
ua_sun
.
sun_·th
,

1343 
PSUTIL_CONN_NONE
);

1344 ià(!
tu¶e
)

1345 
”rÜ
;

1346 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
tu¶e
))

1347 
”rÜ
;

1348 
	`Py_DECREF
(
tu¶e
);

1353 
	`ä“
(
fds_poš‹r
);

1354  
»tLi¡
;

1356 
”rÜ
:

1357 
	`Py_XDECREF
(
tu¶e
);

1358 
	`Py_XDECREF
(
Ïddr
);

1359 
	`Py_XDECREF
(
¿ddr
);

1360 
	`Py_DECREF
(
»tLi¡
);

1362 ià(
fds_poš‹r
 !ð
NULL
) {

1363 
	`ä“
(
fds_poš‹r
);

1365 ià(
Ӽo
 != 0) {

1366  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1368 ià(! 
	`psutž_pid_exi¡s
(
pid
) ) {

1369  
	`NoSuchProûss
();

1372  
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
,

1375 
	}
}

1381 
PyObjeù
 *

1382 
	$psutž_´oc_num_fds
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1384 
pid
;

1385 
pidšfo_»suÉ
;

1386 
num
;

1387 
´oc_fdšfo
 *
fds_poš‹r
;

1389 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1390  
NULL
;

1393 
pidšfo_»suÉ
 = 
	`´oc_pidšfo
(
pid
, 
PROC_PIDLISTFDS
, 0, 
NULL
, 0);

1394 ià(
pidšfo_»suÉ
 <= 0) {

1395  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1398 
fds_poš‹r
 = 
	`m®loc
(
pidšfo_»suÉ
);

1399 ià(
fds_poš‹r
 =ð
NULL
) {

1400  
	`PyE¼_NoMemÜy
();

1402 
pidšfo_»suÉ
 = 
	`´oc_pidšfo
(
pid
, 
PROC_PIDLISTFDS
, 0, 
fds_poš‹r
,

1403 
pidšfo_»suÉ
);

1404 ià(
pidšfo_»suÉ
 <= 0) {

1405 
	`ä“
(
fds_poš‹r
);

1406  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1409 
num
 = (
pidšfo_»suÉ
 / 
PROC_PIDLISTFD_SIZE
);

1410 
	`ä“
(
fds_poš‹r
);

1411  
	`Py_BuždV®ue
("i", 
num
);

1412 
	}
}

1418 
PyObjeù
 *

1419 
	$psutž_Ãt_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1421 *
buf
 = 
NULL
, *
lim
, *
Ãxt
;

1422 
if_msghdr
 *
ifm
;

1423 
mib
[6];

1424 
size_t
 
Ën
;

1425 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

1426 
PyObjeù
 *
py_ifc_šfo
 = 
NULL
;

1428 ià(
py_»tdiù
 =ð
NULL
)

1429  
NULL
;

1431 
mib
[0] = 
CTL_NET
;

1432 
mib
[1] = 
PF_ROUTE
;

1433 
mib
[2] = 0;

1434 
mib
[3] = 0;

1435 
mib
[4] = 
NET_RT_IFLIST2
;

1436 
mib
[5] = 0;

1438 ià(
	`sysùl
(
mib
, 6, 
NULL
, &
Ën
, NULL, 0) < 0) {

1439 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1440 
”rÜ
;

1443 
buf
 = 
	`m®loc
(
Ën
);

1444 ià(
buf
 =ð
NULL
) {

1445 
	`PyE¼_NoMemÜy
();

1446 
”rÜ
;

1449 ià(
	`sysùl
(
mib
, 6, 
buf
, &
Ën
, 
NULL
, 0) < 0) {

1450 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

1451 
”rÜ
;

1454 
lim
 = 
buf
 + 
Ën
;

1456 
Ãxt
 = 
buf
;‚exˆ< 
lim
; ) {

1457 
ifm
 = (
if_msghdr
 *)
Ãxt
;

1458 
Ãxt
 +ð
ifm
->
ifm_msgËn
;

1460 ià(
ifm
->
ifm_ty³
 =ð
RTM_IFINFO2
) {

1461 
py_ifc_šfo
 = 
NULL
;

1462 
if_msghdr2
 *
if2m
 = (if_msghdr2 *)
ifm
;

1463 
sockaddr_dl
 *
sdl
 = (sockaddr_dÈ*)(
if2m
 + 1);

1464 
ifc_Çme
[32];

1466 
	`¡ºýy
(
ifc_Çme
, 
sdl
->
sdl_d©a
, sdl->
sdl_Æ’
);

1467 
ifc_Çme
[
sdl
->
sdl_Æ’
] = 0;

1469 
py_ifc_šfo
 = 
	`Py_BuždV®ue
(

1471 
if2m
->
ifm_d©a
.
ifi_oby‹s
,

1472 
if2m
->
ifm_d©a
.
ifi_iby‹s
,

1473 
if2m
->
ifm_d©a
.
ifi_Ýack‘s
,

1474 
if2m
->
ifm_d©a
.
ifi_ack‘s
,

1475 
if2m
->
ifm_d©a
.
ifi_›¼Üs
,

1476 
if2m
->
ifm_d©a
.
ifi_Û¼Üs
,

1477 
if2m
->
ifm_d©a
.
ifi_iqdrÝs
,

1480 ià(!
py_ifc_šfo
)

1481 
”rÜ
;

1482 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
ifc_Çme
, 
py_ifc_šfo
))

1483 
”rÜ
;

1484 
	`Py_DECREF
(
py_ifc_šfo
);

1491 
	`ä“
(
buf
);

1492  
py_»tdiù
;

1494 
”rÜ
:

1495 
	`Py_XDECREF
(
py_ifc_šfo
);

1496 
	`Py_DECREF
(
py_»tdiù
);

1497 ià(
buf
 !ð
NULL
)

1498 
	`ä“
(
buf
);

1499  
NULL
;

1500 
	}
}

1506 
PyObjeù
 *

1507 
	$psutž_disk_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1509 
CFDiùiÚ¬yRef
 
·»Á_diù
;

1510 
CFDiùiÚ¬yRef
 
´Ýs_diù
;

1511 
CFDiùiÚ¬yRef
 
¡©s_diù
;

1512 
io_»gi¡ry_’Œy_t
 
·»Á
;

1513 
io_»gi¡ry_’Œy_t
 
disk
;

1514 
io_™”©Ü_t
 
disk_li¡
;

1515 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

1516 
PyObjeù
 *
py_disk_šfo
 = 
NULL
;

1518 ià(
py_»tdiù
 =ð
NULL
)

1519  
NULL
;

1522 ià(
	`IOS”viûG‘M©chšgS”viûs
(
kIOMa¡”PÜtDeçuÉ
,

1523 
	`IOS”viûM©chšg
(
kIOMedŸCÏss
),

1524 &
disk_li¡
è!ð
kIOR‘uºSucûss
) {

1525 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

1527 
”rÜ
;

1531 (
disk
 = 
	`IOI‹¿tÜNext
(
disk_li¡
)) != 0) {

1532 
py_disk_šfo
 = 
NULL
;

1533 
·»Á_diù
 = 
NULL
;

1534 
´Ýs_diù
 = 
NULL
;

1535 
¡©s_diù
 = 
NULL
;

1537 ià(
	`IORegi¡ryEÁryG‘P¬’tEÁry
(
disk
, 
kIOS”viûPÏÃ
, &
·»Á
)

1538 !ð
kIOR‘uºSucûss
) {

1539 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

1541 
	`IOObjeùR–—£
(
disk
);

1542 
”rÜ
;

1545 ià(
	`IOObjeùCÚfÜmsTo
(
·»Á
, "IOBlockStorageDriver")) {

1546 ià(
	`IORegi¡ryEÁryC»©eCFPrÝ”t›s
(

1547 
disk
,

1548 (
CFMubËDiùiÚ¬yRef
 *è&
·»Á_diù
,

1549 
kCFAÎoÿtÜDeçuÉ
,

1550 
kNžO±iÚs


1551 è!ð
kIOR‘uºSucûss
)

1553 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

1555 
	`IOObjeùR–—£
(
disk
);

1556 
	`IOObjeùR–—£
(
·»Á
);

1557 
”rÜ
;

1560 ià(
	`IORegi¡ryEÁryC»©eCFPrÝ”t›s
(

1561 
·»Á
,

1562 (
CFMubËDiùiÚ¬yRef
 *è&
´Ýs_diù
,

1563 
kCFAÎoÿtÜDeçuÉ
,

1564 
kNžO±iÚs


1565 è!ð
kIOR‘uºSucûss
)

1567 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

1569 
	`CFR–—£
(
´Ýs_diù
);

1570 
	`IOObjeùR–—£
(
disk
);

1571 
	`IOObjeùR–—£
(
·»Á
);

1572 
”rÜ
;

1575 cÚ¡ 
kMaxDiskNameSize
 = 64;

1576 
CFSŒšgRef
 
disk_Çme_»f
 = (CFSŒšgRef)
	`CFDiùiÚ¬yG‘V®ue
(

1577 
·»Á_diù
, 
	`CFSTR
(
kIOBSDNameKey
));

1578 
disk_Çme
[
kMaxDiskNameSize
];

1580 
	`CFSŒšgG‘CSŒšg
(
disk_Çme_»f
,

1581 
disk_Çme
,

1582 
kMaxDiskNameSize
,

1583 
	`CFSŒšgG‘Sy¡emEncodšg
());

1585 
¡©s_diù
 = (
CFDiùiÚ¬yRef
)
	`CFDiùiÚ¬yG‘V®ue
(

1586 
´Ýs_diù
, 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsKey
));

1588 ià(
¡©s_diù
 =ð
NULL
) {

1589 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

1591 
”rÜ
;

1594 
CFNumb”Ref
 
numb”
;

1595 
št64_t
 
»ads
 = 0;

1596 
št64_t
 
wr™es
 = 0;

1597 
št64_t
 
»ad_by‹s
 = 0;

1598 
št64_t
 
wr™e_by‹s
 = 0;

1599 
št64_t
 
»ad_time
 = 0;

1600 
št64_t
 
wr™e_time
 = 0;

1603 ià((
numb”
 = (
CFNumb”Ref
)
	`CFDiùiÚ¬yG‘V®ue
(

1604 
¡©s_diù
,

1605 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsR—dsKey
))))

1607 
	`CFNumb”G‘V®ue
(
numb”
, 
kCFNumb”SIÁ64Ty³
, &
»ads
);

1609 ià((
numb”
 = (
CFNumb”Ref
)
	`CFDiùiÚ¬yG‘V®ue
(

1610 
¡©s_diù
,

1611 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsWr™esKey
))))

1613 
	`CFNumb”G‘V®ue
(
numb”
, 
kCFNumb”SIÁ64Ty³
, &
wr™es
);

1617 ià((
numb”
 = (
CFNumb”Ref
)
	`CFDiùiÚ¬yG‘V®ue
(

1618 
¡©s_diù
,

1619 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsBy‹sR—dKey
))))

1621 
	`CFNumb”G‘V®ue
(
numb”
, 
kCFNumb”SIÁ64Ty³
, &
»ad_by‹s
);

1623 ià((
numb”
 = (
CFNumb”Ref
)
	`CFDiùiÚ¬yG‘V®ue
(

1624 
¡©s_diù
,

1625 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsBy‹sWr™‹nKey
))))

1627 
	`CFNumb”G‘V®ue
(
numb”
, 
kCFNumb”SIÁ64Ty³
, &
wr™e_by‹s
);

1631 ià((
numb”
 = (
CFNumb”Ref
)
	`CFDiùiÚ¬yG‘V®ue
(

1632 
¡©s_diù
,

1633 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsTÙ®R—dTimeKey
))))

1635 
	`CFNumb”G‘V®ue
(
numb”
, 
kCFNumb”SIÁ64Ty³
, &
»ad_time
);

1637 ià((
numb”
 = (
CFNumb”Ref
)
	`CFDiùiÚ¬yG‘V®ue
(

1638 
¡©s_diù
,

1639 
	`CFSTR
(
kIOBlockStÜageDriv”Sti¡icsTÙ®Wr™eTimeKey
))))

1641 
	`CFNumb”G‘V®ue
(
numb”
, 
kCFNumb”SIÁ64Ty³
, &
wr™e_time
);

1646 
py_disk_šfo
 = 
	`Py_BuždV®ue
(

1648 
»ads
,

1649 
wr™es
,

1650 
»ad_by‹s
,

1651 
wr™e_by‹s
,

1652 
»ad_time
 / 1000 / 1000,

1653 
wr™e_time
 / 1000 / 1000);

1654 ià(!
py_disk_šfo
)

1655 
”rÜ
;

1656 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
disk_Çme
, 
py_disk_šfo
))

1657 
”rÜ
;

1658 
	`Py_DECREF
(
py_disk_šfo
);

1660 
	`CFR–—£
(
·»Á_diù
);

1661 
	`IOObjeùR–—£
(
·»Á
);

1662 
	`CFR–—£
(
´Ýs_diù
);

1663 
	`IOObjeùR–—£
(
disk
);

1667 
	`IOObjeùR–—£
 (
disk_li¡
);

1669  
py_»tdiù
;

1671 
”rÜ
:

1672 
	`Py_XDECREF
(
py_disk_šfo
);

1673 
	`Py_DECREF
(
py_»tdiù
);

1674  
NULL
;

1675 
	}
}

1681 
PyObjeù
 *

1682 
	$psutž_u£rs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1684 
utmpx
 *
utx
;

1685 
PyObjeù
 *
»t_li¡
 = 
	`PyLi¡_New
(0);

1686 
PyObjeù
 *
tu¶e
 = 
NULL
;

1688 ià(
»t_li¡
 =ð
NULL
)

1689  
NULL
;

1690 (
utx
 = 
	`g‘utx’t
()è!ð
NULL
) {

1691 ià(
utx
->
ut_ty³
 !ð
USER_PROCESS
)

1693 
tu¶e
 = 
	`Py_BuždV®ue
(

1695 
utx
->
ut_u£r
,

1696 
utx
->
ut_lše
,

1697 
utx
->
ut_ho¡
,

1698 ()
utx
->
ut_tv
.
tv_£c


1700 ià(!
tu¶e
) {

1701 
	`’dutx’t
();

1702 
”rÜ
;

1704 ià(
	`PyLi¡_Aµ’d
(
»t_li¡
, 
tu¶e
)) {

1705 
	`’dutx’t
();

1706 
”rÜ
;

1708 
	`Py_DECREF
(
tu¶e
);

1711 
	`’dutx’t
();

1712  
»t_li¡
;

1714 
”rÜ
:

1715 
	`Py_XDECREF
(
tu¶e
);

1716 
	`Py_DECREF
(
»t_li¡
);

1717  
NULL
;

1718 
	}
}

1724 
PyM‘hodDef


1725 
	gPsutžM‘hods
[] =

1729 {"´oc_Çme", 
psutž_´oc_Çme
, 
METH_VARARGS
,

1731 {"´oc_cmdlše", 
psutž_´oc_cmdlše
, 
METH_VARARGS
,

1733 {"´oc_exe", 
psutž_´oc_exe
, 
METH_VARARGS
,

1735 {"´oc_cwd", 
psutž_´oc_cwd
, 
METH_VARARGS
,

1737 {"´oc_µid", 
psutž_´oc_µid
, 
METH_VARARGS
,

1739 {"´oc_uids", 
psutž_´oc_uids
, 
METH_VARARGS
,

1741 {"´oc_gids", 
psutž_´oc_gids
, 
METH_VARARGS
,

1743 {"´oc_ýu_times", 
psutž_´oc_ýu_times
, 
METH_VARARGS
,

1745 {"´oc_ü—‹_time", 
psutž_´oc_ü—‹_time
, 
METH_VARARGS
,

1748 {"´oc_memÜy_šfo", 
psutž_´oc_memÜy_šfo
, 
METH_VARARGS
,

1750 {"´oc_num_th»ads", 
psutž_´oc_num_th»ads
, 
METH_VARARGS
,

1752 {"´oc_¡©us", 
psutž_´oc_¡©us
, 
METH_VARARGS
,

1754 {"´oc_th»ads", 
psutž_´oc_th»ads
, 
METH_VARARGS
,

1756 {"´oc_Ý’_fžes", 
psutž_´oc_Ý’_fžes
, 
METH_VARARGS
,

1758 {"´oc_num_fds", 
psutž_´oc_num_fds
, 
METH_VARARGS
,

1760 {"´oc_num_ùx_sw™ches", 
psutž_´oc_num_ùx_sw™ches
, 
METH_VARARGS
,

1762 {"´oc_cÚÃùiÚs", 
psutž_´oc_cÚÃùiÚs
, 
METH_VARARGS
,

1764 {"´oc_‰y_Ä", 
psutž_´oc_‰y_Ä
, 
METH_VARARGS
,

1766 {"´oc_memÜy_m­s", 
psutž_´oc_memÜy_m­s
, 
METH_VARARGS
,

1771 {"pids", 
psutž_pids
, 
METH_VARARGS
,

1773 {"ýu_couÁ_logiÿl", 
psutž_ýu_couÁ_logiÿl
, 
METH_VARARGS
,

1775 {"ýu_couÁ_phys", 
psutž_ýu_couÁ_phys
, 
METH_VARARGS
,

1777 {"vœtu®_mem", 
psutž_vœtu®_mem
, 
METH_VARARGS
,

1779 {"sw­_mem", 
psutž_sw­_mem
, 
METH_VARARGS
,

1781 {"ýu_times", 
psutž_ýu_times
, 
METH_VARARGS
,

1783 {"³r_ýu_times", 
psutž_³r_ýu_times
, 
METH_VARARGS
,

1785 {"boÙ_time", 
psutž_boÙ_time
, 
METH_VARARGS
,

1787 {"disk_·¹™iÚs", 
psutž_disk_·¹™iÚs
, 
METH_VARARGS
,

1790 {"Ãt_io_couÁ”s", 
psutž_Ãt_io_couÁ”s
, 
METH_VARARGS
,

1792 {"disk_io_couÁ”s", 
psutž_disk_io_couÁ”s
, 
METH_VARARGS
,

1794 {"u£rs", 
psutž_u£rs
, 
METH_VARARGS
,

1797 {
NULL
, NULL, 0, NULL}

1801 
	smoduË_¡©e
 {

1802 
PyObjeù
 *
	m”rÜ
;

1805 #ià
PY_MAJOR_VERSION
 >= 3

1806 

	#GETSTATE
(
m
è((
moduË_¡©e
*)
	`PyModuË_G‘S‹
(m))

	)

1808 

	#GETSTATE
(
m
è(&
_¡©e
)

	)

1811 #ià
PY_MAJOR_VERSION
 >= 3

1814 
	$psutž_osx_Œav”£
(
PyObjeù
 *
m
, 
vis™´oc
 
vis™
, *
¬g
) {

1815 
	`Py_VISIT
(
	`GETSTATE
(
m
)->
”rÜ
);

1817 
	}
}

1820 
	$psutž_osx_þ—r
(
PyObjeù
 *
m
) {

1821 
	`Py_CLEAR
(
	`GETSTATE
(
m
)->
”rÜ
);

1823 
	}
}

1826 
PyModuËDef
 
	gmoduËdef
 = {

1827 
PyModuËDef_HEAD_INIT
,

1829 
NULL
,

1830 (
moduË_¡©e
),

1831 
PsutžM‘hods
,

1832 
NULL
,

1833 
psutž_osx_Œav”£
,

1834 
psutž_osx_þ—r
,

1835 
NULL


1838 

	#INITERROR
  
NULL


	)

1840 
PyMODINIT_FUNC
 
	$PyIn™__psutž_osx
()

1843 

	#INITERROR
 

	)

1846 
	$š™_psutž_osx
()

1849 #ià
PY_MAJOR_VERSION
 >= 3

1850 
PyObjeù
 *
moduË
 = 
	`PyModuË_C»©e
(&
moduËdef
);

1852 
PyObjeù
 *
moduË
 = 
	`Py_In™ModuË
("_psutž_osx", 
PsutžM‘hods
);

1856 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SIDL", 
SIDL
);

1857 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SRUN", 
SRUN
);

1858 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SSLEEP", 
SSLEEP
);

1859 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SSTOP", 
SSTOP
);

1860 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SZOMB", 
SZOMB
);

1862 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSED", 
TCPS_CLOSED
);

1863 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSING", 
TCPS_CLOSING
);

1864 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSE_WAIT", 
TCPS_CLOSE_WAIT
);

1865 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_LISTEN", 
TCPS_LISTEN
);

1866 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_ESTABLISHED", 
TCPS_ESTABLISHED
);

1867 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_SYN_SENT", 
TCPS_SYN_SENT
);

1868 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_SYN_RECEIVED", 
TCPS_SYN_RECEIVED
);

1869 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_FIN_WAIT_1", 
TCPS_FIN_WAIT_1
);

1870 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_FIN_WAIT_2", 
TCPS_FIN_WAIT_2
);

1871 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_LAST_ACK", 
TCPS_LAST_ACK
);

1872 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_TIME_WAIT", 
TCPS_TIME_WAIT
);

1873 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "PSUTIL_CONN_NONE", 
PSUTIL_CONN_NONE
);

1875 ià(
moduË
 =ð
NULL
) {

1876 
INITERROR
;

1878 #ià
PY_MAJOR_VERSION
 >= 3

1879  
moduË
;

1881 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_osx.h

7 
	~<PythÚ.h
>

10 
PyObjeù
* 
psutž_´oc_cmdlše
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

11 
PyObjeù
* 
psutž_´oc_cÚÃùiÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

12 
PyObjeù
* 
psutž_´oc_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

13 
PyObjeù
* 
psutž_´oc_ü—‹_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

14 
PyObjeù
* 
psutž_´oc_cwd
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

15 
PyObjeù
* 
psutž_´oc_exe
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

16 
PyObjeù
* 
psutž_´oc_gids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

17 
PyObjeù
* 
psutž_´oc_memÜy_šfo
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

18 
PyObjeù
* 
psutž_´oc_memÜy_m­s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

19 
PyObjeù
* 
psutž_´oc_Çme
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

20 
PyObjeù
* 
psutž_´oc_num_fds
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

21 
PyObjeù
* 
psutž_´oc_num_th»ads
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

22 
PyObjeù
* 
psutž_´oc_Ý’_fžes
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

23 
PyObjeù
* 
psutž_´oc_µid
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

24 
PyObjeù
* 
psutž_´oc_¡©us
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

25 
PyObjeù
* 
psutž_´oc_th»ads
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

26 
PyObjeù
* 
psutž_´oc_‰y_Ä
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

27 
PyObjeù
* 
psutž_´oc_uids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

30 
PyObjeù
* 
psutž_boÙ_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

31 
PyObjeù
* 
psutž_ýu_couÁ_logiÿl
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

32 
PyObjeù
* 
psutž_ýu_couÁ_phys
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

33 
PyObjeù
* 
psutž_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

34 
PyObjeù
* 
psutž_disk_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

35 
PyObjeù
* 
psutž_disk_·¹™iÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

36 
PyObjeù
* 
psutž_Ãt_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

37 
PyObjeù
* 
psutž_³r_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

38 
PyObjeù
* 
psutž_pids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

39 
PyObjeù
* 
psutž_sw­_mem
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

40 
PyObjeù
* 
psutž_u£rs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

41 
PyObjeù
* 
psutž_vœtu®_mem
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_posix.c

9 
	~<PythÚ.h
>

10 
	~<Ӽo.h
>

11 
	~<¡dlib.h
>

12 
	~<sys/»sourû.h
>

14 
	~"_psutž_posix.h
"

20 
PyObjeù
 *

21 
	$psutž_posix_g‘´iÜ™y
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

23 
pid
;

24 
´iÜ™y
;

25 
Ӽo
 = 0;

26 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

27  
NULL
;

29 
´iÜ™y
 = 
	`g‘´iÜ™y
(
PRIO_PROCESS
, 
pid
);

30 ià(
Ӽo
 != 0) {

31  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

33  
	`Py_BuždV®ue
("i", 
´iÜ™y
);

34 
	}
}

40 
PyObjeù
 *

41 
	$psutž_posix_£riÜ™y
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

43 
pid
;

44 
´iÜ™y
;

45 
»tv®
;

46 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "li", &
pid
, &
´iÜ™y
)) {

47  
NULL
;

49 
»tv®
 = 
	`£riÜ™y
(
PRIO_PROCESS
, 
pid
, 
´iÜ™y
);

50 ià(
»tv®
 == -1) {

51  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

53 
	`Py_INCREF
(
Py_NÚe
);

54  
Py_NÚe
;

55 
	}
}

61 
PyM‘hodDef


62 
	gPsutžM‘hods
[] =

64 {"g‘´iÜ™y", 
psutž_posix_g‘´iÜ™y
, 
METH_VARARGS
,

66 {"£riÜ™y", 
psutž_posix_£riÜ™y
, 
METH_VARARGS
,

68 {
NULL
, NULL, 0, NULL}

71 
	smoduË_¡©e
 {

72 
PyObjeù
 *
	m”rÜ
;

75 #ià
PY_MAJOR_VERSION
 >= 3

76 

	#GETSTATE
(
m
è((
moduË_¡©e
*)
	`PyModuË_G‘S‹
(m))

	)

78 

	#GETSTATE
(
m
è(&
_¡©e
)

	)

81 #ià
PY_MAJOR_VERSION
 >= 3

84 
	$psutž_posix_Œav”£
(
PyObjeù
 *
m
, 
vis™´oc
 
vis™
, *
¬g
) {

85 
	`Py_VISIT
(
	`GETSTATE
(
m
)->
”rÜ
);

87 
	}
}

90 
	$psutž_posix_þ—r
(
PyObjeù
 *
m
) {

91 
	`Py_CLEAR
(
	`GETSTATE
(
m
)->
”rÜ
);

93 
	}
}

95 
PyModuËDef
 
	gmoduËdef
 = {

96 
PyModuËDef_HEAD_INIT
,

98 
NULL
,

99 (
moduË_¡©e
),

100 
PsutžM‘hods
,

101 
NULL
,

102 
psutž_posix_Œav”£
,

103 
psutž_posix_þ—r
,

104 
NULL


107 

	#INITERROR
  
NULL


	)

109 
PyMODINIT_FUNC
 
	$PyIn™__psutž_posix
()

112 

	#INITERROR
 

	)

114 
	$š™_psutž_posix
()

117 #ià
PY_MAJOR_VERSION
 >= 3

118 
PyObjeù
 *
moduË
 = 
	`PyModuË_C»©e
(&
moduËdef
);

120 
PyObjeù
 *
moduË
 = 
	`Py_In™ModuË
("_psutž_posix", 
PsutžM‘hods
);

122 ià(
moduË
 =ð
NULL
) {

123 
INITERROR
;

125 #ià
PY_MAJOR_VERSION
 >= 3

126  
moduË
;

128 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_posix.h

7 
	~<PythÚ.h
>

9 
PyObjeù
* 
psutž_posix_g‘´iÜ™y
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

10 
PyObjeù
* 
psutž_posix_£riÜ™y
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_sunos.c

13 
	~<PythÚ.h
>

18 #undeà
_FILE_OFFSET_BITS


19 

	#_STRUCTURED_PROC
 1

	)

23 

	#NEW_MIB_COMPLIANT


	)

25 
	~<sys/ty³s.h
>

26 
	~<sys/¡©.h
>

27 
	~<sys/´oc.h
>

28 
	~<sys/sw­.h
>

29 
	~<sys/sysšfo.h
>

30 
	~<sys/mÁ’t.h
>

31 
	~<sys/mÁb.h
>

32 
	~<sys/´ocfs.h
>

33 
	~<fúŽ.h
>

34 
	~<utmpx.h
>

35 
	~<k¡©.h
>

36 
	~<sys/ioùl.h
>

37 
	~<sys/tihdr.h
>

38 
	~<¡rÝts.h
>

39 
	~<š‘/tý.h
>

40 
	~<¬·/š‘.h
>

42 
	~"_psutž_sunos.h
"

45 

	#TV2DOUBLE
(
t
è((Ñ).
tv_n£c
 * 0.000000001è+ (t).
tv_£c
)

	)

51 
	$psutž_fže_to_¡ruù
(*
·th
, *
f¡ruù
, 
size_t
 
size
)

53 
fd
;

54 
size_t
 
nby‹s
;

55 
fd
 = 
	`Ý’
(
·th
, 
O_RDONLY
);

56 ià(
fd
 == -1) {

57 
	`PyE¼_S‘FromE¼noW™hFž’ame
(
PyExc_OSE¼Ü
, 
·th
);

60 
nby‹s
 = 
	`»ad
(
fd
, 
f¡ruù
, 
size
);

61 ià(
nby‹s
 <= 0) {

62 
	`þo£
(
fd
);

63 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

66 ià(
nby‹s
 !ð
size
) {

67 
	`þo£
(
fd
);

68 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "structure size mismatch");

71 
	`þo£
(
fd
);

72  
nby‹s
;

73 
	}
}

80 
PyObjeù
 *

81 
	$psutž_´oc_basic_šfo
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

83 
pid
;

84 
·th
[100];

85 
psšfo_t
 
šfo
;

87 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

88  
NULL
;

89 
	`¥rštf
(
·th
, "/´oc/%i/psšfo", 
pid
);

90 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
šfo
, (info)))

91  
NULL
;

92  
	`Py_BuždV®ue
("ikkdiiik",

93 
šfo
.
´_µid
,

94 
šfo
.
´_rssize
,

95 
šfo
.
´_size
,

96 
	`TV2DOUBLE
(
šfo
.
´_¡¬t
),

97 
šfo
.
´_lwp
.
´_niû
,

98 
šfo
.
´_Æwp
,

99 
šfo
.
´_lwp
.
´_¡©e
,

100 
šfo
.
´_‰ydev


102 
	}
}

108 
PyObjeù
 *

109 
	$psutž_´oc_Çme_ªd_¬gs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

111 
pid
;

112 
·th
[100];

113 
psšfo_t
 
šfo
;

115 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

116  
NULL
;

117 
	`¥rštf
(
·th
, "/´oc/%i/psšfo", 
pid
);

118 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
šfo
, (info)))

119  
NULL
;

120  
	`Py_BuždV®ue
("ss", 
šfo
.
´_âame
, info.
´_p§rgs
);

121 
	}
}

127 
PyObjeù
 *

128 
	$psutž_´oc_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

130 
pid
;

131 
·th
[100];

132 
p¡©us_t
 
šfo
;

134 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

135  
NULL
;

136 
	`¥rštf
(
·th
, "/´oc/%i/¡©us", 
pid
);

137 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
šfo
, (info)))

138  
NULL
;

140  
	`Py_BuždV®ue
("dd",

141 
	`TV2DOUBLE
(
šfo
.
´_utime
),

142 
	`TV2DOUBLE
(
šfo
.
´_¡ime
));

143 
	}
}

149 
PyObjeù
 *

150 
	$psutž_´oc_üed
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

152 
pid
;

153 
·th
[100];

154 
´üed_t
 
šfo
;

156 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

157  
NULL
;

158 
	`¥rštf
(
·th
, "/´oc/%i/üed", 
pid
);

159 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
šfo
, (info)))

160  
NULL
;

161  
	`Py_BuždV®ue
("iiiiii",

162 
šfo
.
´_ruid
, info.
´_euid
, info.
´_suid
,

163 
šfo
.
´_rgid
, info.
´_egid
, info.
´_sgid
);

164 
	}
}

170 
PyObjeù
 *

171 
	$psutž_´oc_num_ùx_sw™ches
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

173 
pid
;

174 
·th
[100];

175 
´u§ge_t
 
šfo
;

177 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
))

178  
NULL
;

179 
	`¥rštf
(
·th
, "/´oc/%i/u§ge", 
pid
);

180 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
šfo
, (info)))

181  
NULL
;

182  
	`Py_BuždV®ue
("kk", 
šfo
.
´_vùx
, info.
´_iùx
);

183 
	}
}

229 
PyObjeù
 *

230 
	$psutž_´oc_qu”y_th»ad
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

232 
pid
, 
tid
;

233 
·th
[100];

234 
lwp¡©us_t
 
šfo
;

236 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "ii", &
pid
, &
tid
))

237  
NULL
;

238 
	`¥rštf
(
·th
, "/´oc/%i/lwp/%i/lwp¡©us", 
pid
, 
tid
);

239 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
šfo
, (info)))

240  
NULL
;

241  
	`Py_BuždV®ue
("dd",

242 
	`TV2DOUBLE
(
šfo
.
´_utime
),

243 
	`TV2DOUBLE
(
šfo
.
´_¡ime
));

244 
	}
}

250 
PyObjeù
 *

251 
	$psutž_sw­_mem
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

309 
k¡©_ùl_t
 *
kc
;

310 
k¡©_t
 *
k
;

311 
ýu_¡©_t
 *
ýu
;

312 
ýu_couÁ
 = 0;

313 
æag
 = 0;

314 
ušt_t
 
sš
 = 0;

315 
ušt_t
 
sout
 = 0;

317 
kc
 = 
	`k¡©_Ý’
();

318 ià(
kc
 =ð
NULL
) {

319  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);;

322 
k
 = 
kc
->
kc_chaš
;

323 
k
 !ð
NULL
) {

324 ià((
	`¡ºcmp
(
k
->
ks_Çme
, "cpu_stat", 8) == 0) && \

325 (
	`k¡©_»ad
(
kc
, 
k
, 
NULL
) != -1) )

327 
æag
 = 1;

328 
ýu
 = (
ýu_¡©_t
 *è
k
->
ks_d©a
;

329 
sš
 +ð
ýu
->
ýu_vmšfo
.
pgsw­š
;

330 
sout
 +ð
ýu
->
ýu_vmšfo
.
pgsw­out
;

332 
ýu_couÁ
 += 1;

333 
k
 = k->
ks_Ãxt
;

335 
	`k¡©_þo£
(
kc
);

336 ià(!
æag
) {

337 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "no swap device was found");

338  
NULL
;

340  
	`Py_BuždV®ue
("(II)", 
sš
, 
sout
);

341 
	}
}

347 
PyObjeù
 *

348 
	$psutž_u£rs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

350 
utmpx
 *
ut
;

351 
PyObjeù
 *
»t_li¡
 = 
	`PyLi¡_New
(0);

352 
PyObjeù
 *
tu¶e
 = 
NULL
;

353 
PyObjeù
 *
u£r_´oc
 = 
NULL
;

355 ià(
»t_li¡
 =ð
NULL
)

356  
NULL
;

358 
NULL
 !ð(
ut
 = 
	`g‘utx’t
())) {

359 ià(
ut
->
ut_ty³
 =ð
USER_PROCESS
)

360 
u£r_´oc
 = 
Py_True
;

362 
u£r_´oc
 = 
Py_F®£
;

363 
tu¶e
 = 
	`Py_BuždV®ue
(

365 
ut
->
ut_u£r
,

366 
ut
->
ut_lše
,

367 
ut
->
ut_ho¡
,

368 ()
ut
->
ut_tv
.
tv_£c
,

369 
u£r_´oc
);

370 ià(
tu¶e
 =ð
NULL
)

371 
”rÜ
;

372 ià(
	`PyLi¡_Aµ’d
(
»t_li¡
, 
tu¶e
))

373 
”rÜ
;

374 
	`Py_DECREF
(
tu¶e
);

376 
	`’du‹Á
();

378  
»t_li¡
;

380 
”rÜ
:

381 
	`Py_XDECREF
(
tu¶e
);

382 
	`Py_DECREF
(
»t_li¡
);

383 ià(
ut
 !ð
NULL
)

384 
	`’du‹Á
();

385  
NULL
;

386 
	}
}

393 
PyObjeù
 *

394 
	$psutž_disk_·¹™iÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

396 
FILE
 *
fže
;

397 
mÁb
 
mt
;

398 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

399 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

401 ià(
py_»Ži¡
 =ð
NULL
)

402  
NULL
;

404 
fže
 = 
	`fÝ’
(
MNTTAB
, "rb");

405 ià(
fže
 =ð
NULL
) {

406 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

407 
”rÜ
;

410 
	`g‘mÁ’t
(
fže
, &
mt
) == 0) {

411 
py_tu¶e
 = 
	`Py_BuždV®ue
(

413 
mt
.
mÁ_¥ecŸl
,

414 
mt
.
mÁ_mouÁp
,

415 
mt
.
mÁ_f¡y³
,

416 
mt
.
mÁ_mÁÝts
);

417 ià(
py_tu¶e
 =ð
NULL
)

418 
”rÜ
;

419 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

420 
”rÜ
;

421 
	`Py_DECREF
(
py_tu¶e
);

424 
	`fþo£
(
fže
);

425  
py_»Ži¡
;

427 
”rÜ
:

428 
	`Py_XDECREF
(
py_tu¶e
);

429 
	`Py_DECREF
(
py_»Ži¡
);

430 ià(
fže
 !ð
NULL
)

431 
	`fþo£
(
fže
);

432  
NULL
;

433 
	}
}

439 
PyObjeù
 *

440 
	$psutž_³r_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

442 
k¡©_ùl_t
 *
kc
;

443 
k¡©_t
 *
k¥
;

444 
ýu_¡©_t
 
cs
;

445 
numýus
;

446 
i
;

447 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

448 
PyObjeù
 *
py_ýutime
 = 
NULL
;

450 ià(
py_»Ži¡
 =ð
NULL
)

451  
NULL
;

453 
kc
 = 
	`k¡©_Ý’
();

454 ià(
kc
 =ð
NULL
) {

455 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

456 
”rÜ
;

459 
numýus
 = 
	`syscÚf
(
_SC_NPROCESSORS_ONLN
) - 1;

460 
i
 = 0; i <ð
numýus
; i++) {

461 
k¥
 = 
	`k¡©_lookup
(
kc
, "ýu_¡©", 
i
, 
NULL
);

462 ià(
k¥
 =ð
NULL
) {

463 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

464 
”rÜ
;

466 ià(
	`k¡©_»ad
(
kc
, 
k¥
, &
cs
) == -1) {

467 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

468 
”rÜ
;

471 
py_ýutime
 = 
	`Py_BuždV®ue
("ffff",

472 ()
cs
.
ýu_sysšfo
.
ýu
[
CPU_USER
],

473 ()
cs
.
ýu_sysšfo
.
ýu
[
CPU_KERNEL
],

474 ()
cs
.
ýu_sysšfo
.
ýu
[
CPU_IDLE
],

475 ()
cs
.
ýu_sysšfo
.
ýu
[
CPU_WAIT
]);

476 ià(
py_ýutime
 =ð
NULL
)

477 
”rÜ
;

478 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_ýutime
))

479 
”rÜ
;

480 
	`Py_DECREF
(
py_ýutime
);

484 
	`k¡©_þo£
(
kc
);

485  
py_»Ži¡
;

487 
”rÜ
:

488 
	`Py_XDECREF
(
py_ýutime
);

489 
	`Py_DECREF
(
py_»Ži¡
);

490 ià(
kc
 !ð
NULL
)

491 
	`k¡©_þo£
(
kc
);

492  
NULL
;

493 
	}
}

499 
PyObjeù
 *

500 
	$psutž_disk_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

502 
k¡©_ùl_t
 *
kc
;

503 
k¡©_t
 *
k¥
;

504 
k¡©_io_t
 
kio
;

505 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

506 
PyObjeù
 *
py_disk_šfo
 = 
NULL
;

508 ià(
py_»tdiù
 =ð
NULL
)

509  
NULL
;

510 
kc
 = 
	`k¡©_Ý’
();

511 ià(
kc
 =ð
NULL
) {

512 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);;

513 
”rÜ
;

515 
k¥
 = 
kc
->
kc_chaš
;

516 
k¥
 !ð
NULL
) {

517 ià(
k¥
->
ks_ty³
 =ð
KSTAT_TYPE_IO
) {

518 ià(
	`¡rcmp
(
k¥
->
ks_þass
, "disk") == 0) {

519 ià(
	`k¡©_»ad
(
kc
, 
k¥
, &
kio
) == -1) {

520 
	`k¡©_þo£
(
kc
);

521  
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);;

523 
py_disk_šfo
 = 
	`Py_BuždV®ue
(

525 
kio
.
»ads
,

526 
kio
.
wr™es
,

527 
kio
.
Ä—d
,

528 
kio
.
nwr™‹n
,

529 
kio
.
¹ime
 / 1000 / 1000,

530 
kio
.
wtime
 / 1000 / 1000

532 ià(!
py_disk_šfo
)

533 
”rÜ
;

534 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
k¥
->
ks_Çme
,

535 
py_disk_šfo
))

536 
”rÜ
;

537 
	`Py_DECREF
(
py_disk_šfo
);

540 
k¥
 = k¥->
ks_Ãxt
;

542 
	`k¡©_þo£
(
kc
);

544  
py_»tdiù
;

546 
”rÜ
:

547 
	`Py_XDECREF
(
py_disk_šfo
);

548 
	`Py_DECREF
(
py_»tdiù
);

549 ià(
kc
 !ð
NULL
)

550 
	`k¡©_þo£
(
kc
);

551  
NULL
;

552 
	}
}

558 
PyObjeù
 *

559 
	$psutž_´oc_memÜy_m­s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

561 
pid
;

562 
fd
 = -1;

563 
·th
[100];

564 
³rms
[10];

565 *
Çme
;

566 
¡©
 
¡
;

567 
p¡©us_t
 
¡©us
;

569 
´xm­_t
 *
xm­
 = 
NULL
, *
p
;

570 
off_t
 
size
;

571 
size_t
 
Ä—d
;

572 
nm­
;

573 
ušŒ_t
 
´_addr_sz
;

574 
ušŒ_t
 
¡k_ba£_sz
, 
brk_ba£_sz
;

576 
PyObjeù
 *
pytu¶e
 = 
NULL
;

577 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

579 ià(
py_»Ži¡
 =ð
NULL
) {

580  
NULL
;

582 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "i", &
pid
)) {

583 
”rÜ
;

586 
	`¥rštf
(
·th
, "/´oc/%i/¡©us", 
pid
);

587 ià(! 
	`psutž_fže_to_¡ruù
(
·th
, (*)&
¡©us
, (status))) {

588 
”rÜ
;

591 
	`¥rštf
(
·th
, "/´oc/%i/xm­", 
pid
);

592 ià(
	`¡©
(
·th
, &
¡
) == -1) {

593 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

594 
”rÜ
;

597 
size
 = 
¡
.
¡_size
;

599 
fd
 = 
	`Ý’
(
·th
, 
O_RDONLY
);

600 ià(
fd
 == -1) {

601 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

602 
”rÜ
;

605 
xm­
 = (
´xm­_t
 *)
	`m®loc
(
size
);

606 ià(
xm­
 =ð
NULL
) {

607 
	`PyE¼_NoMemÜy
();

608 
”rÜ
;

611 
Ä—d
 = 
	`´—d
(
fd
, 
xm­
, 
size
, 0);

612 
nm­
 = 
Ä—d
 / (
´xm­_t
);

613 
p
 = 
xm­
;

615 
nm­
) {

616 
nm­
 -= 1;

617 ià(
p
 =ð
NULL
) {

618 
p
 += 1;

622 
³rms
[0] = '\0';

623 
´_addr_sz
 = 
p
->
´_vaddr
 +…->
´_size
;

626 
	`¥rštf
(
³rms
, "%c%c%c%c%c%c", 
p
->
´_mæags
 & 
MA_READ
 ? 'r' : '-',

627 
p
->
´_mæags
 & 
MA_WRITE
 ? 'w' : '-',

628 
p
->
´_mæags
 & 
MA_EXEC
 ? 'x' : '-',

629 
p
->
´_mæags
 & 
MA_SHARED
 ? 's' : '-',

630 
p
->
´_mæags
 & 
MA_NORESERVE
 ? 'R' : '-',

631 
p
->
´_mæags
 & 
MA_RESERVED1
 ? '*' : ' ');

634 ià(
	`¡¾’
(
p
->
´_m­Çme
) > 0) {

635 
Çme
 = 
p
->
´_m­Çme
;

638 ià((
p
->
´_mæags
 & 
MA_ISM
è|| (p->´_mæag & 
MA_SHM
)) {

639 
Çme
 = "[shmid]";

642 
¡k_ba£_sz
 = 
¡©us
.
´_¡kba£
 + stus.
´_¡ksize
;

643 
brk_ba£_sz
 = 
¡©us
.
´_brkba£
 + stus.
´_brksize
;

645 ià((
´_addr_sz
 > 
¡©us
.
´_¡kba£
) &&

646 (
p
->
´_vaddr
 < 
¡k_ba£_sz
)) {

647 
Çme
 = "[stack]";

649 ià((
p
->
´_mæags
 & 
MA_ANON
) && \

650 (
´_addr_sz
 > 
¡©us
.
´_brkba£
) && \

651 (
p
->
´_vaddr
 < 
brk_ba£_sz
)) {

652 
Çme
 = "[heap]";

655 
Çme
 = "[anon]";

660 
pytu¶e
 = 
	`Py_BuždV®ue
("iisslll",

661 
p
->
´_vaddr
,

662 
´_addr_sz
,

663 
³rms
,

664 
Çme
,

665 ()
p
->
´_rss
 *…->
´_·gesize
,

666 ()
p
->
´_ªÚ
 *…->
´_·gesize
,

667 ()
p
->
´_locked
 *…->
´_·gesize
);

668 ià(!
pytu¶e
)

669 
”rÜ
;

670 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
pytu¶e
))

671 
”rÜ
;

672 
	`Py_DECREF
(
pytu¶e
);

675 
p
 += 1;

678 
	`þo£
(
fd
);

679 
	`ä“
(
xm­
);

680  
py_»Ži¡
;

682 
”rÜ
:

683 ià(
fd
 != -1)

684 
	`þo£
(
fd
);

685 
	`Py_XDECREF
(
pytu¶e
);

686 
	`Py_DECREF
(
py_»Ži¡
);

687 ià(
xm­
 !ð
NULL
)

688 
	`ä“
(
xm­
);

689  
NULL
;

690 
	}
}

696 
PyObjeù
 *

697 
	$psutž_Ãt_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

699 
k¡©_ùl_t
 *
kc
 = 
NULL
;

700 
k¡©_t
 *
k¥
;

701 
k¡©_Çmed_t
 *
rby‹s
, *
wby‹s
, *
½kts
, *
wpkts
, *
›¼s
, *
Û¼s
;

703 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

704 
PyObjeù
 *
py_ifc_šfo
 = 
NULL
;

706 ià(
py_»tdiù
 =ð
NULL
)

707  
NULL
;

708 
kc
 = 
	`k¡©_Ý’
();

709 ià(
kc
 =ð
NULL
)

710 
”rÜ
;

712 
k¥
 = 
kc
->
kc_chaš
;

713 
k¥
 !ð
NULL
) {

714 ià(
k¥
->
ks_ty³
 !ð
KSTAT_TYPE_NAMED
)

715 
Ãxt
;

716 ià(
	`¡rcmp
(
k¥
->
ks_þass
, "net") != 0)

717 
Ãxt
;

725 ià((
	`¡rcmp
(
k¥
->
ks_moduË
, "link") != 0)) {

726 
Ãxt
;

729 ià(
	`k¡©_»ad
(
kc
, 
k¥
, 
NULL
) == -1) {

730 
Ӽo
 = 0;

734 
rby‹s
 = (
k¡©_Çmed_t
 *)
	`k¡©_d©a_lookup
(
k¥
, "rbytes");

735 
wby‹s
 = (
k¡©_Çmed_t
 *)
	`k¡©_d©a_lookup
(
k¥
, "obytes");

736 
½kts
 = (
k¡©_Çmed_t
 *)
	`k¡©_d©a_lookup
(
k¥
, "ipackets");

737 
wpkts
 = (
k¡©_Çmed_t
 *)
	`k¡©_d©a_lookup
(
k¥
, "opackets");

738 
›¼s
 = (
k¡©_Çmed_t
 *)
	`k¡©_d©a_lookup
(
k¥
, "ierrors");

739 
Û¼s
 = (
k¡©_Çmed_t
 *)
	`k¡©_d©a_lookup
(
k¥
, "oerrors");

741 ià((
rby‹s
 =ð
NULL
è|| (
wby‹s
 =ðNULLè|| (
½kts
 == NULL) ||

742 (
wpkts
 =ð
NULL
è|| (
›¼s
 =ðNULLè|| (
Û¼s
 == NULL))

744 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "kstat_data_lookup() failed");

745 
”rÜ
;

748 #ià
	`defšed
(
_INT64_TYPE
)

749 
py_ifc_šfo
 = 
	`Py_BuždV®ue
("(KKKKkkii)",

750 
rby‹s
->
v®ue
.
ui64
,

751 
wby‹s
->
v®ue
.
ui64
,

752 
½kts
->
v®ue
.
ui64
,

753 
wpkts
->
v®ue
.
ui64
,

754 
›¼s
->
v®ue
.
ui32
,

755 
Û¼s
->
v®ue
.
ui32
,

757 
py_ifc_šfo
 = 
	`Py_BuždV®ue
("(kkkkkkii)",

758 
rby‹s
->
v®ue
.
ui32
,

759 
wby‹s
->
v®ue
.
ui32
,

760 
½kts
->
v®ue
.
ui32
,

761 
wpkts
->
v®ue
.
ui32
,

762 
›¼s
->
v®ue
.
ui32
,

763 
Û¼s
->
v®ue
.
ui32
,

768 ià(!
py_ifc_šfo
)

769 
”rÜ
;

770 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
k¥
->
ks_Çme
, 
py_ifc_šfo
))

771 
”rÜ
;

772 
	`Py_DECREF
(
py_ifc_šfo
);

773 
Ãxt
;

775 
Ãxt
:

776 
k¥
 = k¥->
ks_Ãxt
;

779 
	`k¡©_þo£
(
kc
);

780  
py_»tdiù
;

782 
”rÜ
:

783 
	`Py_XDECREF
(
py_ifc_šfo
);

784 
	`Py_DECREF
(
py_»tdiù
);

785 ià(
kc
 !ð
NULL
)

786 
	`k¡©_þo£
(
kc
);

787  
NULL
;

788 
	}
}

791 #iâdeà
EXPER_IP_AND_ALL_IRES


792 

	#EXPER_IP_AND_ALL_IRES
 (1024+4)

	)

796 
	gPSUTIL_CONN_NONE
 = 128;

809 
PyObjeù
 *

810 
	$psutž_Ãt_cÚÃùiÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

812 
pid
;

813 
sd
 = 
NULL
;

814 
mib2_týCÚnEÁry_t
 *

 = 
NULL
;

815 
mib2_udpEÁry_t
 *
ude
;

816 #ià
	`defšed
(
AF_INET6
)

817 
mib2_tý6CÚnEÁry_t
 *
6
;

818 
mib2_udp6EÁry_t
 *
ude6
;

820 
buf
[512];

821 
i
, 
æags
, 
g‘code
, 
num_’t
, 
¡©e
;

822 
l
[200], 
r
[200];

823 
ÍÜt
, 
½Üt
;

824 
´oûs£d_pid
;

825 
¡rbuf
 
ùlbuf
, 
d©abuf
;

826 
T_Ýtmgmt_»q
 *
tÜ
 = (T_Ýtmgmt_»q *)
buf
;

827 
T_Ýtmgmt_ack
 *
tß
 = (T_Ýtmgmt_ack *)
buf
;

828 
T_”rÜ_ack
 *
‹a
 = (T_”rÜ_ack *)
buf
;

829 
Ýthdr
 *
mibhdr
;

831 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

832 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

833 
PyObjeù
 *
py_Ïddr
 = 
NULL
;

834 
PyObjeù
 *
py_¿ddr
 = 
NULL
;

835 
PyObjeù
 *
af_fž‹r
 = 
NULL
;

836 
PyObjeù
 *
ty³_fž‹r
 = 
NULL
;

838 ià(
py_»Ži¡
 =ð
NULL
)

839  
NULL
;

840 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lOO", &
pid
, &
af_fž‹r
, &
ty³_fž‹r
))

841 
”rÜ
;

842 ià(!
	`PySequ’û_Check
(
af_fž‹r
è|| !PySequ’û_Check(
ty³_fž‹r
)) {

843 
	`PyE¼_S‘SŒšg
(
PyExc_Ty³E¼Ü
, "arg 2 or 3 is‚ot‡ sequence");

844 
”rÜ
;

847 
sd
 = 
	`Ý’
("/dev/¬p", 
O_RDWR
);

848 ià(
sd
 == -1) {

849 
	`PyE¼_S‘FromE¼noW™hFž’ame
(
PyExc_OSE¼Ü
, "/dev/arp");

850 
”rÜ
;

871 
tÜ
->
PRIM_ty³
 = 
T_SVR4_OPTMGMT_REQ
;

872 
tÜ
->
OPT_off£t
 =  (
T_Ýtmgmt_»q
);

873 
tÜ
->
OPT_Ëngth
 =  (
Ýthdr
);

874 
tÜ
->
MGMT_æags
 = 
T_CURRENT
;

875 
mibhdr
 = (
Ýthdr
 *)&
tÜ
[1];

876 
mibhdr
->
Ëv–
 = 
EXPER_IP_AND_ALL_IRES
;

877 
mibhdr
->
Çme
 = 0;

878 
mibhdr
->
Ën
 = 0;

880 
ùlbuf
.
buf
 = buf;

881 
ùlbuf
.
Ën
 = 
tÜ
->
OPT_off£t
 +Ü->
OPT_Ëngth
;

882 
æags
 = 0;

884 ià(
	`putmsg
(
sd
, &
ùlbuf
, (
¡rbuf
 *)0, 
æags
) == -1) {

885 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

886 
”rÜ
;

889 
mibhdr
 = (
Ýthdr
 *)&
tß
[1];

890 
ùlbuf
.
maxËn
 =  (
buf
);

893 
æags
 = 0;

894 
g‘code
 = 
	`g‘msg
(
sd
, &
ùlbuf
, (
¡rbuf
 *)0, &
æags
);

896 ià(
g‘code
 !ð
MOREDATA
 ||

897 
ùlbuf
.
Ën
 <  (
T_Ýtmgmt_ack
) ||

898 
tß
->
PRIM_ty³
 !ð
T_OPTMGMT_ACK
 ||

899 
tß
->
MGMT_æags
 !ð
T_SUCCESS
)

903 ià(
ùlbuf
.
Ën
 >ð (
T_”rÜ_ack
) &&

904 
‹a
->
PRIM_ty³
 =ð
T_ERROR_ACK
)

906 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "ERROR_ACK");

907 
”rÜ
;

909 ià(
g‘code
 == 0 &&

910 
ùlbuf
.
Ën
 >ð (
T_Ýtmgmt_ack
) &&

911 
tß
->
PRIM_ty³
 =ð
T_OPTMGMT_ACK
 &&

912 
tß
->
MGMT_æags
 =ð
T_SUCCESS
)

914 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "ERROR_T_OPTMGMT_ACK");

915 
”rÜ
;

918 
d©abuf
.
maxËn
 = 
mibhdr
->
Ën
;

919 
d©abuf
.
Ën
 = 0;

920 
d©abuf
.
buf
 = (*)
	`m®loc
(()
mibhdr
->
Ën
);

921 ià(!
d©abuf
.
buf
) {

922 
	`PyE¼_NoMemÜy
();

923 
”rÜ
;

926 
æags
 = 0;

927 
g‘code
 = 
	`g‘msg
(
sd
, (
¡rbuf
 *)0, &
d©abuf
, &
æags
);

928 ià(
g‘code
 < 0) {

929 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

930 
”rÜ
;

934 ià(
mibhdr
->
Ëv–
 =ð
MIB2_TCP
 && mibhdr->
Çme
 =ð
MIB2_TCP_13
) {

935 

 = (
mib2_týCÚnEÁry_t
 *)
d©abuf
.
buf
;

936 
num_’t
 = 
mibhdr
->
Ën
 / (
mib2_týCÚnEÁry_t
);

937 
i
 = 0; i < 
num_’t
; i++, 

++) {

938 
´oûs£d_pid
 = 

->
týCÚnC»©iÚProûss
;

939 ià(
pid
 !ð-1 && 
´oûs£d_pid
 !=…id)

942 
	`š‘_ÁÝ
(
AF_INET
, &

->
týCÚnLoÿlAdd»ss
, 
l
, (lip));

943 
	`š‘_ÁÝ
(
AF_INET
, &

->
týCÚnRemAdd»ss
, 
r
, (rip));

944 
ÍÜt
 = 

->
týCÚnLoÿlPÜt
;

945 
½Üt
 = 

->
týCÚnRemPÜt
;

948 
py_Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

949 ià(!
py_Ïddr
)

950 
”rÜ
;

951 ià(
½Üt
 != 0) {

952 
py_¿ddr
 = 
	`Py_BuždV®ue
("(si)", 
r
, 
½Üt
);

955 
py_¿ddr
 = 
	`Py_BuždV®ue
("()");

957 ià(!
py_¿ddr
)

958 
”rÜ
;

959 
¡©e
 = 

->
týCÚnEÁryInfo
.
û_¡©e
;

962 
py_tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNiI)", -1, 
AF_INET
, 
SOCK_STREAM
,

963 
py_Ïddr
, 
py_¿ddr
, 
¡©e
,

964 
´oûs£d_pid
);

965 ià(!
py_tu¶e
) {

966 
”rÜ
;

968 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

969 
”rÜ
;

970 
	`Py_DECREF
(
py_tu¶e
);

973 #ià
	`defšed
(
AF_INET6
)

975 ià(
mibhdr
->
Ëv–
 =ð
MIB2_TCP6
 && mibhdr->
Çme
 =ð
MIB2_TCP6_CONN
)

977 
6
 = (
mib2_tý6CÚnEÁry_t
 *)
d©abuf
.
buf
;

978 
num_’t
 = 
mibhdr
->
Ën
 / (
mib2_tý6CÚnEÁry_t
);

980 
i
 = 0; i < 
num_’t
; i++, 
6
++) {

981 
´oûs£d_pid
 = 
6
->
tý6CÚnC»©iÚProûss
;

982 ià(
pid
 !ð-1 && 
´oûs£d_pid
 !=…id)

985 
	`š‘_ÁÝ
(
AF_INET6
, &
6
->
tý6CÚnLoÿlAdd»ss
, 
l
, (lip));

986 
	`š‘_ÁÝ
(
AF_INET6
, &
6
->
tý6CÚnRemAdd»ss
, 
r
, (rip));

987 
ÍÜt
 = 
6
->
tý6CÚnLoÿlPÜt
;

988 
½Üt
 = 
6
->
tý6CÚnRemPÜt
;

991 
py_Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

992 ià(!
py_Ïddr
)

993 
”rÜ
;

994 ià(
½Üt
 != 0) {

995 
py_¿ddr
 = 
	`Py_BuždV®ue
("(si)", 
r
, 
½Üt
);

998 
py_¿ddr
 = 
	`Py_BuždV®ue
("()");

1000 ià(!
py_¿ddr
)

1001 
”rÜ
;

1002 
¡©e
 = 
6
->
tý6CÚnEÁryInfo
.
û_¡©e
;

1005 
py_tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNiI)", -1, 
AF_INET6
, 
SOCK_STREAM
,

1006 
py_Ïddr
, 
py_¿ddr
, 
¡©e
, 
´oûs£d_pid
);

1007 ià(!
py_tu¶e
) {

1008 
”rÜ
;

1010 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

1011 
”rÜ
;

1012 
	`Py_DECREF
(
py_tu¶e
);

1017 ià(
mibhdr
->
Ëv–
 =ð
MIB2_UDP
 || mibhdr->Ëv– =ð
MIB2_UDP_ENTRY
) {

1018 
ude
 = (
mib2_udpEÁry_t
 *)
d©abuf
.
buf
;

1019 
num_’t
 = 
mibhdr
->
Ën
 / (
mib2_udpEÁry_t
);

1020 
i
 = 0; i < 
num_’t
; i++, 
ude
++) {

1021 
´oûs£d_pid
 = 
ude
->
udpC»©iÚProûss
;

1022 ià(
pid
 !ð-1 && 
´oûs£d_pid
 !=…id)

1029 ià(
´oûs£d_pid
 > 131072)

1031 
	`š‘_ÁÝ
(
AF_INET
, &
ude
->
udpLoÿlAdd»ss
, 
l
, (lip));

1032 
ÍÜt
 = 
ude
->
udpLoÿlPÜt
;

1033 
py_Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

1034 ià(!
py_Ïddr
)

1035 
”rÜ
;

1036 
py_¿ddr
 = 
	`Py_BuždV®ue
("()");

1037 ià(!
py_¿ddr
)

1038 
”rÜ
;

1039 
py_tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNiI)", -1, 
AF_INET
, 
SOCK_DGRAM
,

1040 
py_Ïddr
, 
py_¿ddr
, 
PSUTIL_CONN_NONE
,

1041 
´oûs£d_pid
);

1042 ià(!
py_tu¶e
) {

1043 
”rÜ
;

1045 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

1046 
”rÜ
;

1047 
	`Py_DECREF
(
py_tu¶e
);

1050 #ià
	`defšed
(
AF_INET6
)

1052 ià(
mibhdr
->
Ëv–
 =ð
MIB2_UDP6
 || mibhdr->Ëv– =ð
MIB2_UDP6_ENTRY
) {

1053 
ude6
 = (
mib2_udp6EÁry_t
 *)
d©abuf
.
buf
;

1054 
num_’t
 = 
mibhdr
->
Ën
 / (
mib2_udp6EÁry_t
);

1055 
i
 = 0; i < 
num_’t
; i++, 
ude6
++) {

1056 
´oûs£d_pid
 = 
ude6
->
udp6C»©iÚProûss
;

1057 ià(
pid
 !ð-1 && 
´oûs£d_pid
 !=…id)

1059 
	`š‘_ÁÝ
(
AF_INET6
, &
ude6
->
udp6LoÿlAdd»ss
, 
l
, (lip));

1060 
ÍÜt
 = 
ude6
->
udp6LoÿlPÜt
;

1061 
py_Ïddr
 = 
	`Py_BuždV®ue
("(si)", 
l
, 
ÍÜt
);

1062 ià(!
py_Ïddr
)

1063 
”rÜ
;

1064 
py_¿ddr
 = 
	`Py_BuždV®ue
("()");

1065 ià(!
py_¿ddr
)

1066 
”rÜ
;

1067 
py_tu¶e
 = 
	`Py_BuždV®ue
("(iiiNNiI)", -1, 
AF_INET6
, 
SOCK_DGRAM
,

1068 
py_Ïddr
, 
py_¿ddr
, 
PSUTIL_CONN_NONE
,

1069 
´oûs£d_pid
);

1070 ià(!
py_tu¶e
) {

1071 
”rÜ
;

1073 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

1074 
”rÜ
;

1075 
	`Py_DECREF
(
py_tu¶e
);

1079 
	`ä“
(
d©abuf
.
buf
);

1082 
	`þo£
(
sd
);

1083  
py_»Ži¡
;

1085 
”rÜ
:

1086 
	`Py_XDECREF
(
py_tu¶e
);

1087 
	`Py_XDECREF
(
py_Ïddr
);

1088 
	`Py_XDECREF
(
py_¿ddr
);

1089 
	`Py_DECREF
(
py_»Ži¡
);

1091 ià(
sd
 !ð
NULL
)

1092 
	`þo£
(
sd
);

1093  
NULL
;

1094 
	}
}

1097 
PyObjeù
 *

1098 
	$psutž_boÙ_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1100 
boÙ_time
 = 0.0;

1101 
utmpx
 *
ut
;

1103 
NULL
 !ð(
ut
 = 
	`g‘utx’t
())) {

1104 ià(
ut
->
ut_ty³
 =ð
BOOT_TIME
) {

1105 
boÙ_time
 = ()
ut
->
ut_tv
.
tv_£c
;

1109 
	`’du‹Á
();

1110 ià(
boÙ_time
 != 0.0) {

1111  
	`Py_BuždV®ue
("f", 
boÙ_time
);

1114 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "can't determine bootime");

1115  
NULL
;

1117 
	}
}

1123 
PyObjeù
 *

1124 
	$psutž_ýu_couÁ_phys
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1126 
k¡©_ùl_t
 *
kc
;

1127 
k¡©_t
 *
k¥
;

1128 
nýus
 = 0;

1130 
kc
 = 
	`k¡©_Ý’
();

1131 ià(
kc
 =ð
NULL
)

1132 
”rÜ
;

1133 
k¥
 = 
	`k¡©_lookup
(
kc
, "ýu_šfo", -1, 
NULL
);

1134 ià(
k¥
 =ð
NULL
)

1135 
”rÜ
;

1137 
k¥
 = 
kc
->
kc_chaš
; k¥; k¥ = k¥->
ks_Ãxt
) {

1138 ià(
	`¡rcmp
(
k¥
->
ks_moduË
, "cpu_info") != 0)

1140 ià(
	`k¡©_»ad
(
kc
, 
k¥
, 
NULL
) == NULL)

1141 
”rÜ
;

1142 
nýus
 += 1;

1145 
	`k¡©_þo£
(
kc
);

1146 ià(
nýus
 > 0)

1147  
	`Py_BuždV®ue
("i", 
nýus
);

1149 
”rÜ
;

1151 
”rÜ
:

1153 ià(
kc
 !ð
NULL
)

1154 
	`k¡©_þo£
(
kc
);

1155 
	`Py_INCREF
(
Py_NÚe
);

1156  
Py_NÚe
;

1157 
	}
}

1163 
PyM‘hodDef


1164 
	gPsutžM‘hods
[] =

1167 {"´oc_basic_šfo", 
psutž_´oc_basic_šfo
, 
METH_VARARGS
,

1169 {"´oc_Çme_ªd_¬gs", 
psutž_´oc_Çme_ªd_¬gs
, 
METH_VARARGS
,

1171 {"´oc_ýu_times", 
psutž_´oc_ýu_times
, 
METH_VARARGS
,

1173 {"´oc_üed", 
psutž_´oc_üed
, 
METH_VARARGS
,

1175 {"qu”y_´oûss_th»ad", 
psutž_´oc_qu”y_th»ad
, 
METH_VARARGS
,

1177 {"´oc_memÜy_m­s", 
psutž_´oc_memÜy_m­s
, 
METH_VARARGS
,

1179 {"´oc_num_ùx_sw™ches", 
psutž_´oc_num_ùx_sw™ches
, 
METH_VARARGS
,

1183 {"sw­_mem", 
psutž_sw­_mem
, 
METH_VARARGS
,

1185 {"u£rs", 
psutž_u£rs
, 
METH_VARARGS
,

1187 {"disk_·¹™iÚs", 
psutž_disk_·¹™iÚs
, 
METH_VARARGS
,

1189 {"³r_ýu_times", 
psutž_³r_ýu_times
, 
METH_VARARGS
,

1191 {"disk_io_couÁ”s", 
psutž_disk_io_couÁ”s
, 
METH_VARARGS
,

1193 {"Ãt_io_couÁ”s", 
psutž_Ãt_io_couÁ”s
, 
METH_VARARGS
,

1195 {"boÙ_time", 
psutž_boÙ_time
, 
METH_VARARGS
,

1197 {"ýu_couÁ_phys", 
psutž_ýu_couÁ_phys
, 
METH_VARARGS
,

1199 {"Ãt_cÚÃùiÚs", 
psutž_Ãt_cÚÃùiÚs
, 
METH_VARARGS
,

1202 {
NULL
, NULL, 0, NULL}

1206 
	smoduË_¡©e
 {

1207 
PyObjeù
 *
	m”rÜ
;

1210 #ià
PY_MAJOR_VERSION
 >= 3

1211 

	#GETSTATE
(
m
è((
moduË_¡©e
*)
	`PyModuË_G‘S‹
(m))

	)

1213 

	#GETSTATE
(
m
è(&
_¡©e
)

	)

1216 #ià
PY_MAJOR_VERSION
 >= 3

1219 
	$psutž_sunos_Œav”£
(
PyObjeù
 *
m
, 
vis™´oc
 
vis™
, *
¬g
) {

1220 
	`Py_VISIT
(
	`GETSTATE
(
m
)->
”rÜ
);

1222 
	}
}

1225 
	$psutž_sunos_þ—r
(
PyObjeù
 *
m
) {

1226 
	`Py_CLEAR
(
	`GETSTATE
(
m
)->
”rÜ
);

1228 
	}
}

1230 
PyModuËDef
 
	gmoduËdef
 = {

1231 
PyModuËDef_HEAD_INIT
,

1233 
NULL
,

1234 (
moduË_¡©e
),

1235 
PsutžM‘hods
,

1236 
NULL
,

1237 
psutž_sunos_Œav”£
,

1238 
psutž_sunos_þ—r
,

1239 
NULL


1242 

	#INITERROR
  
NULL


	)

1244 
PyMODINIT_FUNC
 
	$PyIn™__psutž_sunos
()

1247 

	#INITERROR
 

	)

1249 
	$š™_psutž_sunos
()

1252 #ià
PY_MAJOR_VERSION
 >= 3

1253 
PyObjeù
 *
moduË
 = 
	`PyModuË_C»©e
(&
moduËdef
);

1255 
PyObjeù
 *
moduË
 = 
	`Py_In™ModuË
("_psutž_sunos", 
PsutžM‘hods
);

1257 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SSLEEP", 
SSLEEP
);

1258 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SRUN", 
SRUN
);

1259 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SZOMB", 
SZOMB
);

1260 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SSTOP", 
SSTOP
);

1261 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SIDL", 
SIDL
);

1262 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SONPROC", 
SONPROC
);

1263 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "SWAIT", 
SWAIT
);

1265 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "PRNODEV", 
PRNODEV
);

1267 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSED", 
TCPS_CLOSED
);

1268 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSING", 
TCPS_CLOSING
);

1269 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_CLOSE_WAIT", 
TCPS_CLOSE_WAIT
);

1270 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_LISTEN", 
TCPS_LISTEN
);

1271 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_ESTABLISHED", 
TCPS_ESTABLISHED
);

1272 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_SYN_SENT", 
TCPS_SYN_SENT
);

1273 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_SYN_RCVD", 
TCPS_SYN_RCVD
);

1274 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_FIN_WAIT_1", 
TCPS_FIN_WAIT_1
);

1275 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_FIN_WAIT_2", 
TCPS_FIN_WAIT_2
);

1276 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_LAST_ACK", 
TCPS_LAST_ACK
);

1277 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_TIME_WAIT", 
TCPS_TIME_WAIT
);

1279 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_IDLE", 
TCPS_IDLE
);

1281 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "TCPS_BOUND", 
TCPS_BOUND
);

1282 
	`PyModuË_AddIÁCÚ¡ªt
(
moduË
, "PSUTIL_CONN_NONE", 
PSUTIL_CONN_NONE
);

1284 ià(
moduË
 =ð
NULL
) {

1285 
INITERROR
;

1287 #ià
PY_MAJOR_VERSION
 >= 3

1288  
moduË
;

1290 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_sunos.h

7 
	~<PythÚ.h
>

10 
PyObjeù
* 
psutž_´oc_basic_šfo
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

11 
PyObjeù
* 
psutž_´oc_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

12 
PyObjeù
* 
psutž_´oc_üed
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

13 
PyObjeù
* 
psutž_´oc_memÜy_m­s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

14 
PyObjeù
* 
psutž_´oc_Çme_ªd_¬gs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

15 
PyObjeù
* 
psutž_´oc_num_ùx_sw™ches
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

16 
PyObjeù
* 
psutž_´oc_qu”y_th»ad
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

19 
PyObjeù
* 
psutž_boÙ_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

20 
PyObjeù
* 
psutž_ýu_couÁ_phys
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

21 
PyObjeù
* 
psutž_disk_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

22 
PyObjeù
* 
psutž_disk_·¹™iÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

23 
PyObjeù
* 
psutž_Ãt_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

24 
PyObjeù
* 
psutž_³r_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

25 
PyObjeù
* 
psutž_sw­_mem
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

26 
PyObjeù
* 
psutž_u£rs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

27 
PyObjeù
* 
psutž_Ãt_cÚÃùiÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_windows.c

10 

	#WIN32_LEAN_AND_MEAN


	)

12 
	~<PythÚ.h
>

13 
	~<wšdows.h
>

14 
	~<P§pi.h
>

15 
	~<time.h
>

16 
	~<lm.h
>

17 
	~<WšIoCŽ.h
>

18 
	~<tch¬.h
>

19 
	~<Žh–p32.h
>

20 
	~<wšsock2.h
>

21 
	~<hÍ­i.h
>

22 
	~<wt§pi32.h
>

25 #´agm¨
comm’t
(
lib
, "IPHLPAPI.lib")

27 
	~"_psutž_wšdows.h
"

28 
	~"_psutž_commÚ.h
"

29 
	~"¬ch/wšdows/£cur™y.h
"

30 
	~"¬ch/wšdows/´oûss_šfo.h
"

31 
	~"¬ch/wšdows/´oûss_hªdËs.h
"

32 
	~"¬ch/wšdows/Áexpi.h
"

34 #ifdeà
__MINGW32__


35 
	~"¬ch/wšdows/gÍi.h
"

42 
PyObjeù
 *

43 
	$psutž_boÙ_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

45 
u±ime
;

46 
time_t
 
±
;

47 
FILETIME
 
fžeTime
;

48 
Î
;

50 
	`G‘Sy¡emTimeAsFžeTime
(&
fžeTime
);

65 
Î
 = (((
LONGLONG
)(
fžeTime
.
dwHighD©eTime
)) << 32) \

66 + 
fžeTime
.
dwLowD©eTime
;

67 
±
 = (
time_t
)((
Î
 - 116444736000000000ull) / 10000000ull);

71 
u±ime
 = 
	`G‘TickCouÁ
() / 1000.00f;

72  
	`Py_BuždV®ue
("d", ()
±
 - 
u±ime
);

73 
	}
}

79 
PyObjeù
 *

80 
	$psutž_pid_exi¡s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

82 
pid
;

83 
¡©us
;

85 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

86  
NULL
;

89 
¡©us
 = 
	`psutž_pid_is_rušg
(
pid
);

90 ià(-1 =ð
¡©us
) {

91  
NULL
;

93  
	`PyBoÞ_FromLÚg
(
¡©us
);

94 
	}
}

100 
PyObjeù
 *

101 
	$psutž_pids
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

103 
DWORD
 *
´oþi¡
 = 
NULL
;

104 
DWORD
 
numb”OfR‘uºedPIDs
;

105 
DWORD
 
i
;

106 
PyObjeù
 *
pid
 = 
NULL
;

107 
PyObjeù
 *
»Ži¡
 = 
	`PyLi¡_New
(0);

109 ià(
»Ži¡
 =ð
NULL
) {

110  
NULL
;

112 
´oþi¡
 = 
	`psutž_g‘_pids
(&
numb”OfR‘uºedPIDs
);

113 ià(
NULL
 =ð
´oþi¡
) {

114 
”rÜ
;

117 
i
 = 0; i < 
numb”OfR‘uºedPIDs
; i++) {

118 
pid
 = 
	`Py_BuždV®ue
("I", 
´oþi¡
[
i
]);

119 ià(!
pid
)

120 
”rÜ
;

121 ià(
	`PyLi¡_Aµ’d
(
»Ži¡
, 
pid
))

122 
”rÜ
;

123 
	`Py_DECREF
(
pid
);

127 
	`ä“
(
´oþi¡
);

128  
»Ži¡
;

130 
”rÜ
:

131 
	`Py_XDECREF
(
pid
);

132 
	`Py_DECREF
(
»Ži¡
);

133 ià(
´oþi¡
 !ð
NULL
)

134 
	`ä“
(
´oþi¡
);

135  
NULL
;

136 
	}
}

142 
PyObjeù
 *

143 
	$psutž_´oc_kžl
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

145 
HANDLE
 
hProûss
;

146 
pid
;

148 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

149  
NULL
;

151 ià(
pid
 == 0) {

152  
	`AcûssD’›d
();

155 
hProûss
 = 
	`O³nProûss
(
PROCESS_TERMINATE
, 
FALSE
, 
pid
);

156 ià(
hProûss
 =ð
NULL
) {

157 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_INVALID_PARAMETER
) {

159 
	`NoSuchProûss
();

162 
	`PyE¼_S‘FromWšdowsE¼
(0);

164  
NULL
;

168 ià(! 
	`T”mš©eProûss
(
hProûss
, 0)) {

169 
	`PyE¼_S‘FromWšdowsE¼
(0);

170 
	`Clo£HªdË
(
hProûss
);

171  
NULL
;

174 
	`Clo£HªdË
(
hProûss
);

175 
	`Py_INCREF
(
Py_NÚe
);

176  
Py_NÚe
;

177 
	}
}

183 
PyObjeù
 *

184 
	$psutž_´oc_wa™
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

186 
HANDLE
 
hProûss
;

187 
DWORD
 
Ex™Code
;

188 
DWORD
 
»tV®
;

189 
pid
;

190 
timeout
;

192 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "Î", &
pid
, &
timeout
)) {

193  
NULL
;

195 ià(
pid
 == 0) {

196  
	`AcûssD’›d
();

199 
hProûss
 = 
	`O³nProûss
(
SYNCHRONIZE
 | 
PROCESS_QUERY_INFORMATION
,

200 
FALSE
, 
pid
);

201 ià(
hProûss
 =ð
NULL
) {

202 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_INVALID_PARAMETER
) {

205 
	`Py_INCREF
(
Py_NÚe
);

206  
Py_NÚe
;

209 
	`PyE¼_S‘FromWšdowsE¼
(0);

210  
NULL
;

215 
Py_BEGIN_ALLOW_THREADS


216 
»tV®
 = 
	`Wa™FÜSšgËObjeù
(
hProûss
, 
timeout
);

217 
Py_END_ALLOW_THREADS


219 ià(
»tV®
 =ð
WAIT_FAILED
) {

220 
	`Clo£HªdË
(
hProûss
);

221  
	`PyE¼_S‘FromWšdowsE¼
(
	`G‘La¡E¼Ü
());

223 ià(
»tV®
 =ð
WAIT_TIMEOUT
) {

224 
	`Clo£HªdË
(
hProûss
);

225  
	`Py_BuždV®ue
("l", 
WAIT_TIMEOUT
);

230 ià(
	`G‘Ex™CodeProûss
(
hProûss
, &
Ex™Code
) == 0) {

231 
	`Clo£HªdË
(
hProûss
);

232  
	`PyE¼_S‘FromWšdowsE¼
(
	`G‘La¡E¼Ü
());

234 
	`Clo£HªdË
(
hProûss
);

235 #ià
PY_MAJOR_VERSION
 >= 3

236  
	`PyLÚg_FromLÚg
((è
Ex™Code
);

238  
	`PyIÁ_FromLÚg
((è
Ex™Code
);

240 
	}
}

246 
PyObjeù
 *

247 
	$psutž_´oc_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

249 
pid
;

250 
HANDLE
 
hProûss
;

251 
FILETIME
 
áC»©e
, 
áEx™
, 
áK”Ãl
, 
áU£r
;

253 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

254  
NULL
;

257 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

258 ià(
hProûss
 =ð
NULL
) {

259  
NULL
;

262 ià(! 
	`G‘ProûssTimes
(
hProûss
, &
áC»©e
, &
áEx™
, &
áK”Ãl
, &
áU£r
)) {

263 
	`Clo£HªdË
(
hProûss
);

264 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_ACCESS_DENIED
) {

267  
	`NoSuchProûss
();

270 
	`PyE¼_S‘FromWšdowsE¼
(0);

271  
NULL
;

275 
	`Clo£HªdË
(
hProûss
);

286  
	`Py_BuždV®ue
(

288 ()(
áU£r
.
dwHighD©eTime
 * 429.4967296 + \

289 
áU£r
.
dwLowD©eTime
 * 1e-7),

290 ()(
áK”Ãl
.
dwHighD©eTime
 * 429.4967296 + \

291 
áK”Ãl
.
dwLowD©eTime
 * 1e-7)

293 
	}
}

299 
PyObjeù
 *

300 
	$psutž_´oc_ýu_times_2
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

302 
DWORD
 
pid
;

303 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

304 
PVOID
 
bufãr
;

305 
u£r
, 
k”Ãl
;

307 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

308  
NULL
;

310 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

311  
NULL
;

313 
u£r
 = ()
´oûss
->
U£rTime
.
HighP¬t
 * 429.4967296 + \

314 ()
´oûss
->
U£rTime
.
LowP¬t
 * 1e-7;

315 
k”Ãl
 = ()
´oûss
->
K”ÃlTime
.
HighP¬t
 * 429.4967296 + \

316 ()
´oûss
->
K”ÃlTime
.
LowP¬t
 * 1e-7;

317 
	`ä“
(
bufãr
);

318  
	`Py_BuždV®ue
("(dd)", 
u£r
, 
k”Ãl
);

319 
	}
}

326 
PyObjeù
 *

327 
	$psutž_´oc_ü—‹_time
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

329 
pid
;

330 
unix_time
;

331 
DWORD
 
ex™Code
;

332 
HANDLE
 
hProûss
;

333 
BOOL
 
»t
;

334 
FILETIME
 
áC»©e
, 
áEx™
, 
áK”Ãl
, 
áU£r
;

336 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

337  
NULL
;

341 ià(0 =ð
pid
 || 4 ==…id) {

342  
	`psutž_boÙ_time
(
NULL
, NULL);

345 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

346 ià(
hProûss
 =ð
NULL
) {

347  
NULL
;

350 ià(! 
	`G‘ProûssTimes
(
hProûss
, &
áC»©e
, &
áEx™
, &
áK”Ãl
, &
áU£r
)) {

351 
	`Clo£HªdË
(
hProûss
);

352 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_ACCESS_DENIED
) {

355  
	`NoSuchProûss
();

358 
	`PyE¼_S‘FromWšdowsE¼
(0);

359  
NULL
;

368 
»t
 = 
	`G‘Ex™CodeProûss
(
hProûss
, &
ex™Code
);

369 
	`Clo£HªdË
(
hProûss
);

370 ià(
»t
 != 0) {

371 ià(
ex™Code
 !ð
STILL_ACTIVE
) {

372  
	`NoSuchProûss
();

378 ià(
	`G‘La¡E¼Ü
(è!ð
ERROR_ACCESS_DENIED
) {

379 
	`PyE¼_S‘FromWšdowsE¼
(0);

380  
NULL
;

389 
unix_time
 = ((
LONGLONG
)
áC»©e
.
dwHighD©eTime
) << 32;

390 
unix_time
 +ð
áC»©e
.
dwLowD©eTime
 - 116444736000000000LL;

391 
unix_time
 /= 10000000;

392  
	`Py_BuždV®ue
("d", ()
unix_time
);

393 
	}
}

399 
PyObjeù
 *

400 
	$psutž_´oc_ü—‹_time_2
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

402 
DWORD
 
pid
;

403 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

404 
PVOID
 
bufãr
;

405 
unix_time
;

407 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

408  
NULL
;

410 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

411  
NULL
;

414 ià(0 =ð
pid
 || 4 ==…id) {

415  
	`psutž_boÙ_time
(
NULL
, NULL);

422 
unix_time
 = ((
LONGLONG
)
´oûss
->
C»©eTime
.
HighP¬t
) << 32;

423 
unix_time
 +ð
´oûss
->
C»©eTime
.
LowP¬t
 - 116444736000000000LL;

424 
unix_time
 /= 10000000;

425 
	`ä“
(
bufãr
);

426  
	`Py_BuždV®ue
("d", ()
unix_time
);

427 
	}
}

433 
PyObjeù
 *

434 
	$psutž_ýu_couÁ_logiÿl
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

436 
SYSTEM_INFO
 
sy¡em_šfo
;

437 
sy¡em_šfo
.
dwNumb”OfProûssÜs
 = 0;

439 
	`G‘Sy¡emInfo
(&
sy¡em_šfo
);

440 ià(
sy¡em_šfo
.
dwNumb”OfProûssÜs
 == 0) {

442 
	`Py_INCREF
(
Py_NÚe
);

443  
Py_NÚe
;

446  
	`Py_BuždV®ue
("I", 
sy¡em_šfo
.
dwNumb”OfProûssÜs
);

448 
	}
}

451 
	$BOOL
 (
	tWINAPI
 *
	tLPFN_GLPI
è(
	tPSYSTEM_LOGICAL_PROCESSOR_INFORMATION
,

452 
	tPDWORD
);

457 
PyObjeù
 *

458 
	$psutž_ýu_couÁ_phys
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

460 
LPFN_GLPI
 
gÍi
;

461 
DWORD
 
rc
;

462 
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION
 
bufãr
 = 
NULL
;

463 
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION
 
±r
 = 
NULL
;

464 
DWORD
 
Ëngth
 = 0;

465 
DWORD
 
off£t
 = 0;

466 
nýus
 = 0;

468 
gÍi
 = (
LPFN_GLPI
)
	`G‘ProcAdd»ss
(
	`G‘ModuËHªdË
(
	`TEXT
("kernel32")),

470 ià(
gÍi
 =ð
NULL
)

471 
»tuº_nÚe
;

474 
rc
 = 
	`gÍi
(
bufãr
, &
Ëngth
);

475 ià(
rc
 =ð
FALSE
) {

476 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_INSUFFICIENT_BUFFER
) {

477 ià(
bufãr
)

478 
	`ä“
(
bufãr
);

479 
bufãr
 = (
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION
)
	`m®loc
(

480 
Ëngth
);

481 ià(
NULL
 =ð
bufãr
) {

482 
	`PyE¼_NoMemÜy
();

483  
NULL
;

487 
»tuº_nÚe
;

495 
±r
 = 
bufãr
;

496 
off£t
 + (
SYSTEM_LOGICAL_PROCESSOR_INFORMATION
è<ð
Ëngth
) {

497 ià(
±r
->
R–©iÚsh
 =ð
R–©iÚProûssÜCÜe
)

498 
nýus
 += 1;

499 
off£t
 +ð(
SYSTEM_LOGICAL_PROCESSOR_INFORMATION
);

500 
±r
++;

503 
	`ä“
(
bufãr
);

504 ià(
nýus
 == 0)

505 
»tuº_nÚe
;

507  
	`Py_BuždV®ue
("i", 
nýus
);

509 
»tuº_nÚe
:

511 ià(
bufãr
 !ð
NULL
)

512 
	`ä“
(
bufãr
);

513 
	`Py_INCREF
(
Py_NÚe
);

514  
Py_NÚe
;

515 
	}
}

521 
PyObjeù
 *

522 
	$psutž_´oc_cmdlše
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
) {

523 
pid
;

524 
pid_»tuº
;

525 
PyObjeù
 *
¬gli¡
;

527 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

528  
NULL
;

530 ià((
pid
 == 0) || (pid == 4)) {

531  
	`Py_BuždV®ue
("[]");

534 
pid_»tuº
 = 
	`psutž_pid_is_rušg
(
pid
);

535 ià(
pid_»tuº
 == 0) {

536  
	`NoSuchProûss
();

538 ià(
pid_»tuº
 == -1) {

539  
NULL
;

547 
¬gli¡
 = 
	`psutž_g‘_¬g_li¡
(
pid
);

548 iàÐ
NULL
 =ð
¬gli¡
 ) {

550 
	`PyE¼_Cˬ
();

551  
	`Py_BuždV®ue
("[]");

554  
¬gli¡
;

555 
	}
}

561 
PyObjeù
 *

562 
	$psutž_´oc_exe
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
) {

563 
pid
;

564 
HANDLE
 
hProûss
;

565 
wch¬_t
 
exe
[
MAX_PATH
];

566 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

567  
NULL
;

570 
hProûss
 = 
	`psutž_hªdË_äom_pid_wacûss
(
pid
, 
PROCESS_QUERY_INFORMATION
);

571 ià(
NULL
 =ð
hProûss
) {

572  
NULL
;

574 ià(
	`G‘ProûssImageFžeNameW
(
hProûss
, &
exe
, 
MAX_PATH
) == 0) {

575 
	`Clo£HªdË
(
hProûss
);

576 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_INVALID_PARAMETER
) {

578 
	`AcûssD’›d
();

581 
	`PyE¼_S‘FromWšdowsE¼
(0);

583  
NULL
;

585 
	`Clo£HªdË
(
hProûss
);

586  
	`Py_BuždV®ue
("u", 
exe
);

587 
	}
}

593 
PyObjeù
 *

594 
	$psutž_´oc_memÜy_šfo
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

596 
HANDLE
 
hProûss
;

597 
DWORD
 
pid
;

598 #ià(
_WIN32_WINNT
 >= 0x0501)

599 
PROCESS_MEMORY_COUNTERS_EX
 
út
;

601 
PROCESS_MEMORY_COUNTERS
 
út
;

603 
SIZE_T
 
´iv©e
 = 0;

605 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

606  
NULL
;

609 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

610 ià(
NULL
 =ð
hProûss
) {

611  
NULL
;

614 ià(! 
	`G‘ProûssMemÜyInfo
(
hProûss
, &
út
, (cnt)) ) {

615 
	`Clo£HªdË
(
hProûss
);

616  
	`PyE¼_S‘FromWšdowsE¼
(0);

619 #ià(
_WIN32_WINNT
 >= 0x0501)

620 
´iv©e
 = 
út
.
Priv©eU§ge
;

623 
	`Clo£HªdË
(
hProûss
);

629 #ià
	`defšed
(
_WIN64
)

630  
	`Py_BuždV®ue
(

632 
út
.
PageFauÉCouÁ
,

633 ()
út
.
P—kWÜkšgS‘Size
,

634 ()
út
.
WÜkšgS‘Size
,

635 ()
út
.
QuÙaP—kPagedPoÞU§ge
,

636 ()
út
.
QuÙaPagedPoÞU§ge
,

637 ()
út
.
QuÙaP—kNÚPagedPoÞU§ge
,

638 ()
út
.
QuÙaNÚPagedPoÞU§ge
,

639 ()
út
.
PagefžeU§ge
,

640 ()
út
.
P—kPagefžeU§ge
,

641 ()
´iv©e
);

643  
	`Py_BuždV®ue
(

645 
út
.
PageFauÉCouÁ
,

646 ()
út
.
P—kWÜkšgS‘Size
,

647 ()
út
.
WÜkšgS‘Size
,

648 ()
út
.
QuÙaP—kPagedPoÞU§ge
,

649 ()
út
.
QuÙaPagedPoÞU§ge
,

650 ()
út
.
QuÙaP—kNÚPagedPoÞU§ge
,

651 ()
út
.
QuÙaNÚPagedPoÞU§ge
,

652 ()
út
.
PagefžeU§ge
,

653 ()
út
.
P—kPagefžeU§ge
,

654 ()
´iv©e
);

656 
	}
}

662 
PyObjeù
 *

663 
	$psutž_´oc_memÜy_šfo_2
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

665 
DWORD
 
pid
;

666 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

667 
PVOID
 
bufãr
;

668 
SIZE_T
 
´iv©e
;

669 
pçuÉ_couÁ
;

671 #ià
	`defšed
(
_WIN64
)

672 
m1
, 
m2
, 
m3
, 
m4
, 
m5
, 
m6
, 
m7
, 
m8
;

674 
m1
, 
m2
, 
m3
, 
m4
, 
m5
, 
m6
, 
m7
, 
m8
;

677 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

678  
NULL
;

680 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

681  
NULL
;

684 #ià(
_WIN32_WINNT
 >= 0x0501)

685 
´iv©e
 = 
´oûss
->
Priv©ePageCouÁ
;

687 
´iv©e
 = 0;

689 
pçuÉ_couÁ
 = 
´oûss
->
PageFauÉCouÁ
;

691 
m1
 = 
´oûss
->
P—kWÜkšgS‘Size
;

692 
m2
 = 
´oûss
->
WÜkšgS‘Size
;

693 
m3
 = 
´oûss
->
QuÙaP—kPagedPoÞU§ge
;

694 
m4
 = 
´oûss
->
QuÙaPagedPoÞU§ge
;

695 
m5
 = 
´oûss
->
QuÙaP—kNÚPagedPoÞU§ge
;

696 
m6
 = 
´oûss
->
QuÙaNÚPagedPoÞU§ge
;

697 
m7
 = 
´oûss
->
PagefžeU§ge
;

698 
m8
 = 
´oûss
->
P—kPagefžeU§ge
;

700 
	`ä“
(
bufãr
);

706 #ià
	`defšed
(
_WIN64
)

707  
	`Py_BuždV®ue
("(kKKKKKKKKK)",

709  
	`Py_BuždV®ue
("(kIIIIIIIII)",

711 
pçuÉ_couÁ
, 
m1
, 
m2
, 
m3
, 
m4
, 
m5
, 
m6
, 
m7
, 
m8
, 
´iv©e
);

712 
	}
}

719 
PyObjeù
 *

720 
	$psutž_vœtu®_mem
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

722 
MEMORYSTATUSEX
 
memInfo
;

723 
memInfo
.
dwL’gth
 = (
MEMORYSTATUSEX
);

725 ià(! 
	`Glob®MemÜyStusEx
(&
memInfo
) ) {

726  
	`PyE¼_S‘FromWšdowsE¼
(0);

729  
	`Py_BuždV®ue
("(LLLLLL)",

730 
memInfo
.
uÎTÙ®Phys
,

731 
memInfo
.
uÎAvažPhys
,

732 
memInfo
.
uÎTÙ®PageFže
,

733 
memInfo
.
uÎAvažPageFže
,

734 
memInfo
.
uÎTÙ®Vœtu®
,

735 
memInfo
.
uÎAvažVœtu®
);

736 
	}
}

739 

	#LO_T
 (()1e-7)

	)

740 

	#HI_T
 (
LO_T
*4294967296.0)

	)

748 
PyObjeù
 *

749 
	$psutž_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

751 
idË
, 
k”Ãl
, 
u£r
, 
sy¡em
;

752 
FILETIME
 
idË_time
, 
k”Ãl_time
, 
u£r_time
;

754 ià(!
	`G‘Sy¡emTimes
(&
idË_time
, &
k”Ãl_time
, &
u£r_time
)) {

755  
	`PyE¼_S‘FromWšdowsE¼
(0);

758 
idË
 = ()((
HI_T
 * 
idË_time
.
dwHighD©eTime
) + \

759 (
LO_T
 * 
idË_time
.
dwLowD©eTime
));

760 
u£r
 = ()((
HI_T
 * 
u£r_time
.
dwHighD©eTime
) + \

761 (
LO_T
 * 
u£r_time
.
dwLowD©eTime
));

762 
k”Ãl
 = ()((
HI_T
 * 
k”Ãl_time
.
dwHighD©eTime
) + \

763 (
LO_T
 * 
k”Ãl_time
.
dwLowD©eTime
));

768 
sy¡em
 = (
k”Ãl
 - 
idË
);

769  
	`Py_BuždV®ue
("(fff)", 
u£r
, 
sy¡em
, 
idË
);

770 
	}
}

776 
PyObjeù
 *

777 
	$psutž_³r_ýu_times
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

779 
idË
, 
k”Ãl
, 
u£r
;

780 
	`DWORD
 (
	t_¡dÿÎ
 * 
	tNTQSI_PROC
è(, 
	tPVOID
, 
	tULONG
, 
	tPULONG
);

781 
NTQSI_PROC
 
NtQu”ySy¡emInfÜm©iÚ
;

782 
HINSTANCE
 
hNtDÎ
;

783 
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
 *
¥pi
 = 
NULL
;

784 
SYSTEM_INFO
 
si
;

785 
UINT
 
i
;

786 
PyObjeù
 *
¬g
 = 
NULL
;

787 
PyObjeù
 *
»Ži¡
 = 
	`PyLi¡_New
(0);

789 ià(
»Ži¡
 =ð
NULL
)

790  
NULL
;

793 
hNtDÎ
 = 
	`LßdLib¿ry
(
	`TEXT
("ntdll.dll"));

794 ià(
hNtDÎ
 !ð
NULL
) {

796 
NtQu”ySy¡emInfÜm©iÚ
 = (
NTQSI_PROC
)
	`G‘ProcAdd»ss
(

797 
hNtDÎ
, "NtQuerySystemInformation");

799 ià(
NtQu”ySy¡emInfÜm©iÚ
 !ð
NULL
)

802 
	`G‘Sy¡emInfo
(&
si
);

806 
¥pi
 = (
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
 *) \

807 
	`m®loc
(
si
.
dwNumb”OfProûssÜs
 * \

808 (
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
));

809 ià(
¥pi
 !ð
NULL
)

812 ià(0 =ð
	`NtQu”ySy¡emInfÜm©iÚ
(

813 
Sy¡emProûssÜP”fÜmªûInfÜm©iÚ
,

814 
¥pi
,

815 
si
.
dwNumb”OfProûssÜs
 * 

816 (
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
),

817 
NULL
)

822 
idË
 = 
u£r
 = 
k”Ãl
 = 0;

823 
i
 = 0; i < 
si
.
dwNumb”OfProûssÜs
; i++) {

824 
¬g
 = 
NULL
;

825 
u£r
 = ()((
HI_T
 * 
¥pi
[
i
].
U£rTime
.
HighP¬t
) +

826 (
LO_T
 * 
¥pi
[
i
].
U£rTime
.
LowP¬t
));

827 
idË
 = ()((
HI_T
 * 
¥pi
[
i
].
IdËTime
.
HighP¬t
) +

828 (
LO_T
 * 
¥pi
[
i
].
IdËTime
.
LowP¬t
));

829 
k”Ãl
 = ()((
HI_T
 * 
¥pi
[
i
].
K”ÃlTime
.
HighP¬t
) +

830 (
LO_T
 * 
¥pi
[
i
].
K”ÃlTime
.
LowP¬t
));

834 
¬g
 = 
	`Py_BuždV®ue
("(ddd)",

835 
u£r
,

836 
k”Ãl
 - 
idË
,

837 
idË
);

838 ià(!
¬g
)

839 
”rÜ
;

840 ià(
	`PyLi¡_Aµ’d
(
»Ži¡
, 
¬g
))

841 
”rÜ
;

842 
	`Py_DECREF
(
¬g
);

844 
	`ä“
(
¥pi
);

845 
	`F»eLib¿ry
(
hNtDÎ
);

846  
»Ži¡
;

852 
”rÜ
;

854 
”rÜ
:

855 
	`Py_XDECREF
(
¬g
);

856 
	`Py_DECREF
(
»Ži¡
);

857 ià(
¥pi
) {

858 
	`ä“
(
¥pi
);

860 ià(
hNtDÎ
) {

861 
	`F»eLib¿ry
(
hNtDÎ
);

863 
	`PyE¼_S‘FromWšdowsE¼
(0);

864  
NULL
;

865 
	}
}

872 
PyObjeù
 *

873 
	$psutž_´oc_cwd
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

875 
pid
;

876 
HANDLE
 
´oûssHªdË
 = 
NULL
;

877 
PVOID
 
³bAdd»ss
;

878 
PVOID
 
¹lU£rProcP¬amsAdd»ss
;

879 
UNICODE_STRING
 
cu¼’tDœeùÜy
;

880 
WCHAR
 *
cu¼’tDœeùÜyCÚ‹Á
 = 
NULL
;

881 
PyObjeù
 *
»tuºPyObj
 = 
NULL
;

882 
PyObjeù
 *
cwd_äom_wch¬
 = 
NULL
;

883 
PyObjeù
 *
cwd
 = 
NULL
;

885 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

886  
NULL
;

889 
´oûssHªdË
 = 
	`psutž_hªdË_äom_pid
(
pid
);

890 ià(
´oûssHªdË
 =ð
NULL
) {

891  
NULL
;

894 
³bAdd»ss
 = 
	`psutž_g‘_³b_add»ss
(
´oûssHªdË
);

897 #ifdeà
_WIN64


898 ià(!
	`R—dProûssMemÜy
(
´oûssHªdË
, (
PCHAR
)
³bAdd»ss
 + 32,

899 &
¹lU£rProcP¬amsAdd»ss
, (
PVOID
), 
NULL
))

901 ià(!
	`R—dProûssMemÜy
(
´oûssHªdË
, (
PCHAR
)
³bAdd»ss
 + 0x10,

902 &
¹lU£rProcP¬amsAdd»ss
, (
PVOID
), 
NULL
))

905 
	`Clo£HªdË
(
´oûssHªdË
);

906 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_PARTIAL_COPY
) {

908  
	`AcûssD’›d
();

911  
	`PyE¼_S‘FromWšdowsE¼
(0);

920 #ifdeà
_WIN64


921 ià(!
	`R—dProûssMemÜy
(
´oûssHªdË
, (
PCHAR
)
¹lU£rProcP¬amsAdd»ss
 + 56,

922 &
cu¼’tDœeùÜy
, (cu¼’tDœeùÜy), 
NULL
))

924 ià(!
	`R—dProûssMemÜy
(
´oûssHªdË
,

925 (
PCHAR
)
¹lU£rProcP¬amsAdd»ss
 + 0x24,

926 &
cu¼’tDœeùÜy
, (cu¼’tDœeùÜy), 
NULL
))

929 
	`Clo£HªdË
(
´oûssHªdË
);

930 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_PARTIAL_COPY
) {

932  
	`AcûssD’›d
();

935  
	`PyE¼_S‘FromWšdowsE¼
(0);

940 
cu¼’tDœeùÜyCÚ‹Á
 = (
WCHAR
 *)
	`m®loc
(
cu¼’tDœeùÜy
.
L’gth
 + 1);

941 ià(
cu¼’tDœeùÜyCÚ‹Á
 =ð
NULL
) {

942 
	`PyE¼_NoMemÜy
();

943 
”rÜ
;

947 ià(!
	`R—dProûssMemÜy
(
´oûssHªdË
, 
cu¼’tDœeùÜy
.
Bufãr
,

948 
cu¼’tDœeùÜyCÚ‹Á
, 
cu¼’tDœeùÜy
.
L’gth
,

949 
NULL
))

951 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_PARTIAL_COPY
) {

953 
	`AcûssD’›d
();

956 
	`PyE¼_S‘FromWšdowsE¼
(0);

958 
”rÜ
;

964 
cu¼’tDœeùÜyCÚ‹Á
[(
cu¼’tDœeùÜy
.
L’gth
 / (
WCHAR
))] = '\0';

967 
cwd_äom_wch¬
 = 
	`PyUnicode_FromWideCh¬
(
cu¼’tDœeùÜyCÚ‹Á
,

968 
	`wc¦’
(
cu¼’tDœeùÜyCÚ‹Á
));

969 ià(
cwd_äom_wch¬
 =ð
NULL
)

970 
”rÜ
;

972 #ià
PY_MAJOR_VERSION
 >= 3

973 
cwd
 = 
	`PyUnicode_FromObjeù
(
cwd_äom_wch¬
);

975 
cwd
 = 
	`PyUnicode_AsUTF8SŒšg
(
cwd_äom_wch¬
);

977 ià(
cwd
 =ð
NULL
)

978 
”rÜ
;

982 
»tuºPyObj
 = 
	`Py_BuždV®ue
("N", 
cwd
);

983 ià(!
»tuºPyObj
)

984 
”rÜ
;

986 
	`Py_DECREF
(
cwd_äom_wch¬
);

988 
	`Clo£HªdË
(
´oûssHªdË
);

989 
	`ä“
(
cu¼’tDœeùÜyCÚ‹Á
);

990  
»tuºPyObj
;

992 
”rÜ
:

993 
	`Py_XDECREF
(
cwd_äom_wch¬
);

994 
	`Py_XDECREF
(
cwd
);

995 
	`Py_XDECREF
(
»tuºPyObj
);

996 ià(
cu¼’tDœeùÜyCÚ‹Á
 !ð
NULL
)

997 
	`ä“
(
cu¼’tDœeùÜyCÚ‹Á
);

998 ià(
´oûssHªdË
 !ð
NULL
)

999 
	`Clo£HªdË
(
´oûssHªdË
);

1000  
NULL
;

1001 
	}
}

1008 
	$psutž_´oc_su¥’d_Ü_»sume
(
DWORD
 
pid
, 
su¥’d
)

1011 
HANDLE
 
hTh»adSÇp
 = 
NULL
;

1012 
THREADENTRY32
 
‹32
 = {0};

1014 ià(
pid
 == 0) {

1015 
	`AcûssD’›d
();

1016  
FALSE
;

1019 
hTh»adSÇp
 = 
	`C»©eToÞh–p32SÇpshÙ
(
TH32CS_SNAPTHREAD
, 0);

1020 ià(
hTh»adSÇp
 =ð
INVALID_HANDLE_VALUE
) {

1021 
	`PyE¼_S‘FromWšdowsE¼
(0);

1022  
FALSE
;

1026 
‹32
.
dwSize
 = (
THREADENTRY32
);

1028 ià(! 
	`Th»ad32Fœ¡
(
hTh»adSÇp
, &
‹32
)) {

1029 
	`PyE¼_S‘FromWšdowsE¼
(0);

1030 
	`Clo£HªdË
(
hTh»adSÇp
);

1031  
FALSE
;

1039 ià(
‹32
.
th32OwÃrProûssID
 =ð
pid
)

1041 
HANDLE
 
hTh»ad
 = 
	`O³nTh»ad
(
THREAD_SUSPEND_RESUME
, 
FALSE
,

1042 
‹32
.
th32Th»adID
);

1043 ià(
hTh»ad
 =ð
NULL
) {

1044 
	`PyE¼_S‘FromWšdowsE¼
(0);

1045 
	`Clo£HªdË
(
hTh»ad
);

1046 
	`Clo£HªdË
(
hTh»adSÇp
);

1047  
FALSE
;

1049 ià(
su¥’d
 == 1)

1051 ià(
	`Su¥’dTh»ad
(
hTh»ad
è=ð(
DWORD
) - 1) {

1052 
	`PyE¼_S‘FromWšdowsE¼
(0);

1053 
	`Clo£HªdË
(
hTh»ad
);

1054 
	`Clo£HªdË
(
hTh»adSÇp
);

1055  
FALSE
;

1060 ià(
	`ResumeTh»ad
(
hTh»ad
è=ð(
DWORD
) - 1) {

1061 
	`PyE¼_S‘FromWšdowsE¼
(0);

1062 
	`Clo£HªdË
(
hTh»ad
);

1063 
	`Clo£HªdË
(
hTh»adSÇp
);

1064  
FALSE
;

1067 
	`Clo£HªdË
(
hTh»ad
);

1069 } 
	`Th»ad32Next
(
hTh»adSÇp
, &
‹32
));

1071 
	`Clo£HªdË
(
hTh»adSÇp
);

1072  
TRUE
;

1073 
	}
}

1076 
PyObjeù
 *

1077 
	$psutž_´oc_su¥’d
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1079 
pid
;

1080 
su¥’d
 = 1;

1081 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1082  
NULL
;

1085 ià(! 
	`psutž_´oc_su¥’d_Ü_»sume
(
pid
, 
su¥’d
)) {

1086  
NULL
;

1088 
	`Py_INCREF
(
Py_NÚe
);

1089  
Py_NÚe
;

1090 
	}
}

1093 
PyObjeù
 *

1094 
	$psutž_´oc_»sume
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1096 
pid
;

1097 
su¥’d
 = 0;

1098 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1099  
NULL
;

1102 ià(! 
	`psutž_´oc_su¥’d_Ü_»sume
(
pid
, 
su¥’d
)) {

1103  
NULL
;

1105 
	`Py_INCREF
(
Py_NÚe
);

1106  
Py_NÚe
;

1107 
	}
}

1110 
PyObjeù
 *

1111 
	$psutž_´oc_num_th»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1113 
DWORD
 
pid
;

1114 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

1115 
PVOID
 
bufãr
;

1116 
num
;

1118 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1119  
NULL
;

1121 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

1122  
NULL
;

1124 
num
 = ()
´oûss
->
Numb”OfTh»ads
;

1125 
	`ä“
(
bufãr
);

1126  
	`Py_BuždV®ue
("i", 
num
);

1127 
	}
}

1130 
PyObjeù
 *

1131 
	$psutž_´oc_th»ads
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1133 
HANDLE
 
hTh»ad
;

1134 
THREADENTRY32
 
‹32
 = {0};

1135 
pid
;

1136 
pid_»tuº
;

1137 
rc
;

1138 
FILETIME
 
áDummy
, 
áK”Ãl
, 
áU£r
;

1139 
PyObjeù
 *
»tLi¡
 = 
	`PyLi¡_New
(0);

1140 
PyObjeù
 *
pyTu¶e
 = 
NULL
;

1141 
HANDLE
 
hTh»adSÇp
 = 
NULL
;

1143 ià(
»tLi¡
 =ð
NULL
) {

1144  
NULL
;

1146 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1147 
”rÜ
;

1149 ià(
pid
 == 0) {

1152 
	`AcûssD’›d
();

1153 
”rÜ
;

1156 
pid_»tuº
 = 
	`psutž_pid_is_rušg
(
pid
);

1157 ià(
pid_»tuº
 == 0) {

1158 
	`NoSuchProûss
();

1159 
”rÜ
;

1161 ià(
pid_»tuº
 == -1) {

1162 
”rÜ
;

1165 
hTh»adSÇp
 = 
	`C»©eToÞh–p32SÇpshÙ
(
TH32CS_SNAPTHREAD
, 0);

1166 ià(
hTh»adSÇp
 =ð
INVALID_HANDLE_VALUE
) {

1167 
	`PyE¼_S‘FromWšdowsE¼
(0);

1168 
”rÜ
;

1172 
‹32
.
dwSize
 = (
THREADENTRY32
);

1174 ià(! 
	`Th»ad32Fœ¡
(
hTh»adSÇp
, &
‹32
)) {

1175 
	`PyE¼_S‘FromWšdowsE¼
(0);

1176 
”rÜ
;

1183 ià(
‹32
.
th32OwÃrProûssID
 =ð
pid
)

1185 
pyTu¶e
 = 
NULL
;

1186 
hTh»ad
 = 
NULL
;

1187 
hTh»ad
 = 
	`O³nTh»ad
(
THREAD_QUERY_INFORMATION
,

1188 
FALSE
, 
‹32
.
th32Th»adID
);

1189 ià(
hTh»ad
 =ð
NULL
) {

1194 
rc
 = 
	`G‘Th»adTimes
(
hTh»ad
, &
áDummy
, &áDummy, &
áK”Ãl
,

1195 &
áU£r
);

1196 ià(
rc
 == 0) {

1197 
	`PyE¼_S‘FromWšdowsE¼
(0);

1198 
”rÜ
;

1210 
pyTu¶e
 = 
	`Py_BuždV®ue
(

1212 
‹32
.
th32Th»adID
,

1213 ()(
áU£r
.
dwHighD©eTime
 * 429.4967296 + \

1214 
áU£r
.
dwLowD©eTime
 * 1e-7),

1215 ()(
áK”Ãl
.
dwHighD©eTime
 * 429.4967296 + \

1216 
áK”Ãl
.
dwLowD©eTime
 * 1e-7));

1217 ià(!
pyTu¶e
)

1218 
”rÜ
;

1219 ià(
	`PyLi¡_Aµ’d
(
»tLi¡
, 
pyTu¶e
))

1220 
”rÜ
;

1221 
	`Py_DECREF
(
pyTu¶e
);

1223 
	`Clo£HªdË
(
hTh»ad
);

1225 } 
	`Th»ad32Next
(
hTh»adSÇp
, &
‹32
));

1227 
	`Clo£HªdË
(
hTh»adSÇp
);

1228  
»tLi¡
;

1230 
”rÜ
:

1231 
	`Py_XDECREF
(
pyTu¶e
);

1232 
	`Py_DECREF
(
»tLi¡
);

1233 ià(
hTh»ad
 !ð
NULL
)

1234 
	`Clo£HªdË
(
hTh»ad
);

1235 ià(
hTh»adSÇp
 !ð
NULL
) {

1236 
	`Clo£HªdË
(
hTh»adSÇp
);

1238  
NULL
;

1239 
	}
}

1242 
PyObjeù
 *

1243 
	$psutž_´oc_Ý’_fžes
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1245 
pid
;

1246 
HANDLE
 
´oûssHªdË
;

1247 
DWORD
 
acûss
 = 
PROCESS_DUP_HANDLE
 | 
PROCESS_QUERY_INFORMATION
;

1248 
PyObjeù
 *
fžesLi¡
;

1250 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1251  
NULL
;

1254 
´oûssHªdË
 = 
	`psutž_hªdË_äom_pid_wacûss
(
pid
, 
acûss
);

1255 ià(
´oûssHªdË
 =ð
NULL
) {

1256  
NULL
;

1259 
fžesLi¡
 = 
	`psutž_g‘_Ý’_fžes
(
pid
, 
´oûssHªdË
);

1260 
	`Clo£HªdË
(
´oûssHªdË
);

1261 ià(
fžesLi¡
 =ð
NULL
) {

1262  
	`PyE¼_S‘FromWšdowsE¼
(0);

1264  
fžesLi¡
;

1265 
	}
}

1273 
PyObjeù
 *

1274 
	$psutž_wš32_Qu”yDosDeviû
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1276 
LPCTSTR
 
ÍDeviûP©h
;

1277 
TCHAR
 
d
 = 
	`TEXT
('A');

1278 
TCHAR
 
szBuff
[5];

1280 ià(!
	`PyArg_P¬£Tu¶e
(
¬gs
, "s", &
ÍDeviûP©h
)) {

1281  
NULL
;

1284 
d
 <ð
	`TEXT
('Z'))

1286 
TCHAR
 
szDeviûName
[3] = {
d
, 
	`TEXT
(':'), TEXT('\0')};

1287 
TCHAR
 
szT¬g‘
[512] = {0};

1288 ià(
	`Qu”yDosDeviû
(
szDeviûName
, 
szT¬g‘
, 511) != 0) {

1289 ià(
	`_tcscmp
(
ÍDeviûP©h
, 
szT¬g‘
) == 0) {

1290 
	`_¡´štf
(
szBuff
, 
	`TEXT
("%c:"), 
d
);

1291  
	`Py_BuždV®ue
("s", 
szBuff
);

1294 
d
++;

1296  
	`Py_BuždV®ue
("s", "");

1297 
	}
}

1303 
PyObjeù
 *

1304 
	$psutž_´oc_u£ºame
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1306 
pid
;

1307 
HANDLE
 
´oûssHªdË
;

1308 
HANDLE
 
tok’HªdË
;

1309 
PTOKEN_USER
 
u£r
;

1310 
ULONG
 
bufãrSize
;

1311 
PTSTR
 
Çme
;

1312 
ULONG
 
ÇmeSize
;

1313 
PTSTR
 
domašName
;

1314 
ULONG
 
domašNameSize
;

1315 
SID_NAME_USE
 
ÇmeU£
;

1316 
PTSTR
 
fuÎName
;

1317 
PyObjeù
 *
»tuºObjeù
;

1319 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1320  
NULL
;

1323 
´oûssHªdË
 = 
	`psutž_hªdË_äom_pid_wacûss
(

1324 
pid
, 
PROCESS_QUERY_INFORMATION
);

1325 ià(
´oûssHªdË
 =ð
NULL
) {

1326  
NULL
;

1329 ià(!
	`O³nProûssTok’
(
´oûssHªdË
, 
TOKEN_QUERY
, &
tok’HªdË
)) {

1330 
	`Clo£HªdË
(
´oûssHªdË
);

1331  
	`PyE¼_S‘FromWšdowsE¼
(0);

1334 
	`Clo£HªdË
(
´oûssHªdË
);

1338 
bufãrSize
 = 0x100;

1339 
u£r
 = 
	`m®loc
(
bufãrSize
);

1340 ià(
u£r
 =ð
NULL
) {

1341  
	`PyE¼_NoMemÜy
();

1344 ià(!
	`G‘Tok’InfÜm©iÚ
(
tok’HªdË
, 
Tok’U£r
, 
u£r
, 
bufãrSize
,

1345 &
bufãrSize
))

1347 
	`ä“
(
u£r
);

1348 
u£r
 = 
	`m®loc
(
bufãrSize
);

1349 ià(
u£r
 =ð
NULL
) {

1350 
	`Clo£HªdË
(
tok’HªdË
);

1351  
	`PyE¼_NoMemÜy
();

1353 ià(!
	`G‘Tok’InfÜm©iÚ
(
tok’HªdË
, 
Tok’U£r
, 
u£r
, 
bufãrSize
,

1354 &
bufãrSize
))

1356 
	`ä“
(
u£r
);

1357 
	`Clo£HªdË
(
tok’HªdË
);

1358  
	`PyE¼_S‘FromWšdowsE¼
(0);

1362 
	`Clo£HªdË
(
tok’HªdË
);

1365 
ÇmeSize
 = 0x100;

1366 
domašNameSize
 = 0x100;

1368 
Çme
 = 
	`m®loc
(
ÇmeSize
 * (
TCHAR
));

1369 ià(
Çme
 =ð
NULL
)

1370  
	`PyE¼_NoMemÜy
();

1371 
domašName
 = 
	`m®loc
(
domašNameSize
 * (
TCHAR
));

1372 ià(
domašName
 =ð
NULL
)

1373  
	`PyE¼_NoMemÜy
();

1375 ià(!
	`LookupAccouÁSid
(
NULL
, 
u£r
->
U£r
.
Sid
, 
Çme
, &
ÇmeSize
, 
domašName
,

1376 &
domašNameSize
, &
ÇmeU£
))

1378 
	`ä“
(
Çme
);

1379 
	`ä“
(
domašName
);

1380 
Çme
 = 
	`m®loc
(
ÇmeSize
 * (
TCHAR
));

1381 ià(
Çme
 =ð
NULL
)

1382  
	`PyE¼_NoMemÜy
();

1383 
domašName
 = 
	`m®loc
(
domašNameSize
 * (
TCHAR
));

1384 ià(
domašName
 =ð
NULL
)

1385  
	`PyE¼_NoMemÜy
();

1386 ià(!
	`LookupAccouÁSid
(
NULL
, 
u£r
->
U£r
.
Sid
, 
Çme
, &
ÇmeSize
,

1387 
domašName
, &
domašNameSize
, &
ÇmeU£
))

1389 
	`ä“
(
Çme
);

1390 
	`ä“
(
domašName
);

1391 
	`ä“
(
u£r
);

1393  
	`PyE¼_S‘FromWšdowsE¼
(0);

1397 
ÇmeSize
 = 
	`_tc¦’
(
Çme
);

1398 
domašNameSize
 = 
	`_tc¦’
(
domašName
);

1401 
fuÎName
 = 
	`m®loc
((
domašNameSize
 + 1 + 
ÇmeSize
 + 1è* (
TCHAR
));

1402 ià(
fuÎName
 =ð
NULL
) {

1403 
	`ä“
(
Çme
);

1404 
	`ä“
(
domašName
);

1405 
	`ä“
(
u£r
);

1406  
	`PyE¼_NoMemÜy
();

1408 
	`memýy
(
fuÎName
, 
domašName
, 
domašNameSize
);

1409 
fuÎName
[
domašNameSize
] = '\\';

1410 
	`memýy
(&
fuÎName
[
domašNameSize
 + 1], 
Çme
, 
ÇmeSize
);

1411 
fuÎName
[
domašNameSize
 + 1 + 
ÇmeSize
] = '\0';

1413 
»tuºObjeù
 = 
	`Py_BuždV®ue
("s", 
fuÎName
);

1415 
	`ä“
(
fuÎName
);

1416 
	`ä“
(
Çme
);

1417 
	`ä“
(
domašName
);

1418 
	`ä“
(
u£r
);

1420  
»tuºObjeù
;

1421 
	}
}

1426 #iâdeà
_IPRTRMIB_H


1427 
	s_MIB_TCP6ROW_OWNER_PID
 {

1428 
UCHAR
 
	mucLoÿlAddr
[16];

1429 
DWORD
 
	mdwLoÿlScÝeId
;

1430 
DWORD
 
	mdwLoÿlPÜt
;

1431 
UCHAR
 
	mucRemÙeAddr
[16];

1432 
DWORD
 
	mdwRemÙeScÝeId
;

1433 
DWORD
 
	mdwRemÙePÜt
;

1434 
DWORD
 
	mdwS‹
;

1435 
DWORD
 
	mdwOwnšgPid
;

1436 } 
	tMIB_TCP6ROW_OWNER_PID
, *
	tPMIB_TCP6ROW_OWNER_PID
;

1438 
	s_MIB_TCP6TABLE_OWNER_PID
 {

1439 
DWORD
 
	mdwNumEÁr›s
;

1440 
MIB_TCP6ROW_OWNER_PID
 
	mbË
[
ANY_SIZE
];

1441 } 
	tMIB_TCP6TABLE_OWNER_PID
, *
	tPMIB_TCP6TABLE_OWNER_PID
;

1444 #iâdeà
__IPHLPAPI_H__


1445 
	sš6_addr
 {

1447 
UCHAR
 
	mBy‹
[16];

1448 
USHORT
 
	mWÜd
[8];

1449 } 
	mu
;

1450 } 
	tIN6_ADDR
, *
	tPIN6_ADDR
, 
	tFAR
 *
	tLPIN6_ADDR
;

1452 
	e_UDP_TABLE_CLASS
 {

1453 
	mUDP_TABLE_BASIC
,

1454 
	mUDP_TABLE_OWNER_PID
,

1455 
	mUDP_TABLE_OWNER_MODULE


1456 } 
	tUDP_TABLE_CLASS
, *
	tPUDP_TABLE_CLASS
;

1458 
	s_MIB_UDPROW_OWNER_PID
 {

1459 
DWORD
 
	mdwLoÿlAddr
;

1460 
DWORD
 
	mdwLoÿlPÜt
;

1461 
DWORD
 
	mdwOwnšgPid
;

1462 } 
	tMIB_UDPROW_OWNER_PID
, *
	tPMIB_UDPROW_OWNER_PID
;

1464 
	s_MIB_UDPTABLE_OWNER_PID
 {

1465 
DWORD
 
	mdwNumEÁr›s
;

1466 
MIB_UDPROW_OWNER_PID
 
	mbË
[
ANY_SIZE
];

1467 } 
	tMIB_UDPTABLE_OWNER_PID
, *
	tPMIB_UDPTABLE_OWNER_PID
;

1470 
	s_MIB_UDP6ROW_OWNER_PID
 {

1471 
UCHAR
 
	mucLoÿlAddr
[16];

1472 
DWORD
 
	mdwLoÿlScÝeId
;

1473 
DWORD
 
	mdwLoÿlPÜt
;

1474 
DWORD
 
	mdwOwnšgPid
;

1475 } 
	tMIB_UDP6ROW_OWNER_PID
, *
	tPMIB_UDP6ROW_OWNER_PID
;

1477 
	s_MIB_UDP6TABLE_OWNER_PID
 {

1478 
DWORD
 
	mdwNumEÁr›s
;

1479 
MIB_UDP6ROW_OWNER_PID
 
	mbË
[
ANY_SIZE
];

1480 } 
	tMIB_UDP6TABLE_OWNER_PID
, *
	tPMIB_UDP6TABLE_OWNER_PID
;

1483 

	#BYTESWAP_USHORT
(
x
è((((
USHORT
)(xè<< 8è| ((USHORT)(xè>> 8)è& 0xffff)

	)

1485 #iâdeà
AF_INET6


1486 

	#AF_INET6
 23

	)

1489 

	#_psutž_cÚn_deüef_objs
() \

1490 
	`Py_DECREF
(
_AF_INET
); \

1491 
	`Py_DECREF
(
_AF_INET6
);\

1492 
	`Py_DECREF
(
_SOCK_STREAM
);\

1493 
	`Py_DECREF
(
_SOCK_DGRAM
);

	)

1496 
	gPSUTIL_CONN_NONE
 = 128;

1502 
PyObjeù
 *

1503 
	$psutž_Ãt_cÚÃùiÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1505 
nuÎ_add»ss
[4] = { 0, 0, 0, 0 };

1507 
pid
;

1508 
PyObjeù
 *
cÚÃùiÚsLi¡
;

1509 
PyObjeù
 *
cÚÃùiÚTu¶e
 = 
NULL
;

1510 
PyObjeù
 *
af_fž‹r
 = 
NULL
;

1511 
PyObjeù
 *
ty³_fž‹r
 = 
NULL
;

1513 
PyObjeù
 *
_AF_INET
 = 
	`PyLÚg_FromLÚg
(()
AF_INET
);

1514 
PyObjeù
 *
_AF_INET6
 = 
	`PyLÚg_FromLÚg
(()
AF_INET6
);

1515 
PyObjeù
 *
_SOCK_STREAM
 = 
	`PyLÚg_FromLÚg
(()
SOCK_STREAM
);

1516 
PyObjeù
 *
_SOCK_DGRAM
 = 
	`PyLÚg_FromLÚg
(()
SOCK_DGRAM
);

1518 
	`PSTR
 (
	tNTAPI
 * 
	t_RŽIpv4Add»ssToSŒšgA
)(
	tš_addr
 *, 
	tPSTR
);

1519 
_RŽIpv4Add»ssToSŒšgA
 
¹lIpv4Add»ssToSŒšgA
;

1520 
	`PSTR
 (
	tNTAPI
 * 
	t_RŽIpv6Add»ssToSŒšgA
)(
	tš6_addr
 *, 
	tPSTR
);

1521 
_RŽIpv6Add»ssToSŒšgA
 
¹lIpv6Add»ssToSŒšgA
;

1522 
	`DWORD
 (
	tWINAPI
 * 
	t_G‘Ex‹ndedTýTabË
)(
	tPVOID
, 
	tPDWORD
, 
	tBOOL
, 
	tULONG
,

1523 
	tTCP_TABLE_CLASS
, 
	tULONG
);

1524 
_G‘Ex‹ndedTýTabË
 
g‘Ex‹ndedTýTabË
;

1525 
	`DWORD
 (
	tWINAPI
 * 
	t_G‘Ex‹ndedUdpTabË
)(
	tPVOID
, 
	tPDWORD
, 
	tBOOL
, 
	tULONG
,

1526 
	tUDP_TABLE_CLASS
, 
	tULONG
);

1527 
_G‘Ex‹ndedUdpTabË
 
g‘Ex‹ndedUdpTabË
;

1528 
PVOID
 
bË
 = 
NULL
;

1529 
DWORD
 
bËSize
;

1530 
PMIB_TCPTABLE_OWNER_PID
 
tý4TabË
;

1531 
PMIB_UDPTABLE_OWNER_PID
 
udp4TabË
;

1532 
PMIB_TCP6TABLE_OWNER_PID
 
tý6TabË
;

1533 
PMIB_UDP6TABLE_OWNER_PID
 
udp6TabË
;

1534 
ULONG
 
i
;

1535 
CHAR
 
add»ssBufãrLoÿl
[65];

1536 
PyObjeù
 *
add»ssTu¶eLoÿl
 = 
NULL
;

1537 
CHAR
 
add»ssBufãrRemÙe
[65];

1538 
PyObjeù
 *
add»ssTu¶eRemÙe
 = 
NULL
;

1540 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lOO", &
pid
, &
af_fž‹r
, &
ty³_fž‹r
)) {

1541 
	`_psutž_cÚn_deüef_objs
();

1542  
NULL
;

1545 ià(!
	`PySequ’û_Check
(
af_fž‹r
è|| !PySequ’û_Check(
ty³_fž‹r
)) {

1546 
	`_psutž_cÚn_deüef_objs
();

1547 
	`PyE¼_S‘SŒšg
(
PyExc_Ty³E¼Ü
, "arg 2 or 3 is‚ot‡ sequence");

1548  
NULL
;

1551 ià(
pid
 != -1) {

1552 ià(
	`psutž_pid_is_rušg
(
pid
) == 0) {

1553 
	`_psutž_cÚn_deüef_objs
();

1554  
	`NoSuchProûss
();

1560 
HMODULE
 
ÁdÎ
;

1561 
HMODULE
 
hÍ­i
;

1563 
ÁdÎ
 = 
	`LßdLib¿ry
(
	`TEXT
("ntdll.dll"));

1564 
¹lIpv4Add»ssToSŒšgA
 = (
_RŽIpv4Add»ssToSŒšgA
)
	`G‘ProcAdd»ss
(

1565 
ÁdÎ
, "RtlIpv4AddressToStringA");

1566 
¹lIpv6Add»ssToSŒšgA
 = (
_RŽIpv6Add»ssToSŒšgA
)
	`G‘ProcAdd»ss
(

1567 
ÁdÎ
, "RtlIpv6AddressToStringA");

1570 
hÍ­i
 = 
	`LßdLib¿ry
(
	`TEXT
("iphlpapi.dll"));

1571 
g‘Ex‹ndedTýTabË
 = (
_G‘Ex‹ndedTýTabË
)
	`G‘ProcAdd»ss
(
hÍ­i
,

1573 
g‘Ex‹ndedUdpTabË
 = (
_G‘Ex‹ndedUdpTabË
)
	`G‘ProcAdd»ss
(
hÍ­i
,

1575 
	`F»eLib¿ry
(
ÁdÎ
);

1576 
	`F»eLib¿ry
(
hÍ­i
);

1579 ià((
g‘Ex‹ndedTýTabË
 =ð
NULL
è|| (
g‘Ex‹ndedUdpTabË
 == NULL)) {

1580 
	`PyE¼_S‘SŒšg
(
PyExc_NÙIm¶em’‹dE¼Ü
,

1582 
	`_psutž_cÚn_deüef_objs
();

1583  
NULL
;

1586 
cÚÃùiÚsLi¡
 = 
	`PyLi¡_New
(0);

1587 ià(
cÚÃùiÚsLi¡
 =ð
NULL
) {

1588 
	`_psutž_cÚn_deüef_objs
();

1589  
NULL
;

1594 ià((
	`PySequ’û_Cڏšs
(
af_fž‹r
, 
_AF_INET
) == 1) &&

1595 (
	`PySequ’û_Cڏšs
(
ty³_fž‹r
, 
_SOCK_STREAM
) == 1))

1597 
bË
 = 
NULL
;

1598 
cÚÃùiÚTu¶e
 = 
NULL
;

1599 
add»ssTu¶eLoÿl
 = 
NULL
;

1600 
add»ssTu¶eRemÙe
 = 
NULL
;

1601 
bËSize
 = 0;

1602 
	`g‘Ex‹ndedTýTabË
(
NULL
, &
bËSize
, 
FALSE
, 
AF_INET
,

1603 
TCP_TABLE_OWNER_PID_ALL
, 0);

1605 
bË
 = 
	`m®loc
(
bËSize
);

1606 ià(
bË
 =ð
NULL
) {

1607 
	`PyE¼_NoMemÜy
();

1608 
”rÜ
;

1611 ià(
	`g‘Ex‹ndedTýTabË
(
bË
, &
bËSize
, 
FALSE
, 
AF_INET
,

1612 
TCP_TABLE_OWNER_PID_ALL
, 0) == 0)

1614 
tý4TabË
 = 
bË
;

1616 
i
 = 0; i < 
tý4TabË
->
dwNumEÁr›s
; i++)

1618 ià(
pid
 != -1) {

1619 ià(
tý4TabË
->
bË
[
i
].
dwOwnšgPid
 !ð
pid
) {

1624 ià(
tý4TabË
->
bË
[
i
].
dwLoÿlAddr
 != 0 ||

1625 
tý4TabË
->
bË
[
i
].
dwLoÿlPÜt
 != 0)

1627 
š_addr
 
addr
;

1629 
addr
.
S_un
.
S_addr
 = 
tý4TabË
->
bË
[
i
].
dwLoÿlAddr
;

1630 
	`¹lIpv4Add»ssToSŒšgA
(&
addr
, 
add»ssBufãrLoÿl
);

1631 
add»ssTu¶eLoÿl
 = 
	`Py_BuždV®ue
(

1633 
add»ssBufãrLoÿl
,

1634 
	`BYTESWAP_USHORT
(
tý4TabË
->
bË
[
i
].
dwLoÿlPÜt
));

1637 
add»ssTu¶eLoÿl
 = 
	`PyTu¶e_New
(0);

1640 ià(
add»ssTu¶eLoÿl
 =ð
NULL
)

1641 
”rÜ
;

1645 ià((
tý4TabË
->
bË
[
i
].
dwRemÙeAddr
 != 0 ||

1646 
tý4TabË
->
bË
[
i
].
dwRemÙePÜt
 != 0) &&

1647 (
tý4TabË
->
bË
[
i
].
dwS‹
 !ð
MIB_TCP_STATE_LISTEN
))

1649 
š_addr
 
addr
;

1651 
addr
.
S_un
.
S_addr
 = 
tý4TabË
->
bË
[
i
].
dwRemÙeAddr
;

1652 
	`¹lIpv4Add»ssToSŒšgA
(&
addr
, 
add»ssBufãrRemÙe
);

1653 
add»ssTu¶eRemÙe
 = 
	`Py_BuždV®ue
(

1655 
add»ssBufãrRemÙe
,

1656 
	`BYTESWAP_USHORT
(
tý4TabË
->
bË
[
i
].
dwRemÙePÜt
));

1660 
add»ssTu¶eRemÙe
 = 
	`PyTu¶e_New
(0);

1663 ià(
add»ssTu¶eRemÙe
 =ð
NULL
)

1664 
”rÜ
;

1666 
cÚÃùiÚTu¶e
 = 
	`Py_BuždV®ue
(

1669 
AF_INET
,

1670 
SOCK_STREAM
,

1671 
add»ssTu¶eLoÿl
,

1672 
add»ssTu¶eRemÙe
,

1673 
tý4TabË
->
bË
[
i
].
dwS‹
,

1674 
tý4TabË
->
bË
[
i
].
dwOwnšgPid
);

1675 ià(!
cÚÃùiÚTu¶e
)

1676 
”rÜ
;

1677 ià(
	`PyLi¡_Aµ’d
(
cÚÃùiÚsLi¡
, 
cÚÃùiÚTu¶e
))

1678 
”rÜ
;

1679 
	`Py_DECREF
(
cÚÃùiÚTu¶e
);

1683 
	`ä“
(
bË
);

1688 ià((
	`PySequ’û_Cڏšs
(
af_fž‹r
, 
_AF_INET6
) == 1) &&

1689 (
	`PySequ’û_Cڏšs
(
ty³_fž‹r
, 
_SOCK_STREAM
) == 1))

1691 
bË
 = 
NULL
;

1692 
cÚÃùiÚTu¶e
 = 
NULL
;

1693 
add»ssTu¶eLoÿl
 = 
NULL
;

1694 
add»ssTu¶eRemÙe
 = 
NULL
;

1695 
bËSize
 = 0;

1696 
	`g‘Ex‹ndedTýTabË
(
NULL
, &
bËSize
, 
FALSE
, 
AF_INET6
,

1697 
TCP_TABLE_OWNER_PID_ALL
, 0);

1699 
bË
 = 
	`m®loc
(
bËSize
);

1700 ià(
bË
 =ð
NULL
) {

1701 
	`PyE¼_NoMemÜy
();

1702 
”rÜ
;

1705 ià(
	`g‘Ex‹ndedTýTabË
(
bË
, &
bËSize
, 
FALSE
, 
AF_INET6
,

1706 
TCP_TABLE_OWNER_PID_ALL
, 0) == 0)

1708 
tý6TabË
 = 
bË
;

1710 
i
 = 0; i < 
tý6TabË
->
dwNumEÁr›s
; i++)

1712 ià(
pid
 != -1) {

1713 ià(
tý6TabË
->
bË
[
i
].
dwOwnšgPid
 !ð
pid
) {

1718 ià(
	`memcmp
(
tý6TabË
->
bË
[
i
].
ucLoÿlAddr
, 
nuÎ_add»ss
, 16)

1719 !ð0 || 
tý6TabË
->
bË
[
i
].
dwLoÿlPÜt
 != 0)

1721 
š6_addr
 
addr
;

1723 
	`memýy
(&
addr
, 
tý6TabË
->
bË
[
i
].
ucLoÿlAddr
, 16);

1724 
	`¹lIpv6Add»ssToSŒšgA
(&
addr
, 
add»ssBufãrLoÿl
);

1725 
add»ssTu¶eLoÿl
 = 
	`Py_BuždV®ue
(

1727 
add»ssBufãrLoÿl
,

1728 
	`BYTESWAP_USHORT
(
tý6TabË
->
bË
[
i
].
dwLoÿlPÜt
));

1732 
add»ssTu¶eLoÿl
 = 
	`PyTu¶e_New
(0);

1735 ià(
add»ssTu¶eLoÿl
 =ð
NULL
)

1736 
”rÜ
;

1740 ià((
	`memcmp
(
tý6TabË
->
bË
[
i
].
ucRemÙeAddr
, 
nuÎ_add»ss
, 16)

1742 
tý6TabË
->
bË
[
i
].
dwRemÙePÜt
 != 0) &&

1743 (
tý6TabË
->
bË
[
i
].
dwS‹
 !ð
MIB_TCP_STATE_LISTEN
))

1745 
š6_addr
 
addr
;

1747 
	`memýy
(&
addr
, 
tý6TabË
->
bË
[
i
].
ucRemÙeAddr
, 16);

1748 
	`¹lIpv6Add»ssToSŒšgA
(&
addr
, 
add»ssBufãrRemÙe
);

1749 
add»ssTu¶eRemÙe
 = 
	`Py_BuždV®ue
(

1751 
add»ssBufãrRemÙe
,

1752 
	`BYTESWAP_USHORT
(
tý6TabË
->
bË
[
i
].
dwRemÙePÜt
));

1756 
add»ssTu¶eRemÙe
 = 
	`PyTu¶e_New
(0);

1759 ià(
add»ssTu¶eRemÙe
 =ð
NULL
)

1760 
”rÜ
;

1762 
cÚÃùiÚTu¶e
 = 
	`Py_BuždV®ue
(

1765 
AF_INET6
,

1766 
SOCK_STREAM
,

1767 
add»ssTu¶eLoÿl
,

1768 
add»ssTu¶eRemÙe
,

1769 
tý6TabË
->
bË
[
i
].
dwS‹
,

1770 
tý6TabË
->
bË
[
i
].
dwOwnšgPid
);

1771 ià(!
cÚÃùiÚTu¶e
)

1772 
”rÜ
;

1773 ià(
	`PyLi¡_Aµ’d
(
cÚÃùiÚsLi¡
, 
cÚÃùiÚTu¶e
))

1774 
”rÜ
;

1775 
	`Py_DECREF
(
cÚÃùiÚTu¶e
);

1779 
	`ä“
(
bË
);

1784 ià((
	`PySequ’û_Cڏšs
(
af_fž‹r
, 
_AF_INET
) == 1) &&

1785 (
	`PySequ’û_Cڏšs
(
ty³_fž‹r
, 
_SOCK_DGRAM
) == 1))

1787 
bË
 = 
NULL
;

1788 
cÚÃùiÚTu¶e
 = 
NULL
;

1789 
add»ssTu¶eLoÿl
 = 
NULL
;

1790 
add»ssTu¶eRemÙe
 = 
NULL
;

1791 
bËSize
 = 0;

1792 
	`g‘Ex‹ndedUdpTabË
(
NULL
, &
bËSize
, 
FALSE
, 
AF_INET
,

1793 
UDP_TABLE_OWNER_PID
, 0);

1795 
bË
 = 
	`m®loc
(
bËSize
);

1796 ià(
bË
 =ð
NULL
) {

1797 
	`PyE¼_NoMemÜy
();

1798 
”rÜ
;

1801 ià(
	`g‘Ex‹ndedUdpTabË
(
bË
, &
bËSize
, 
FALSE
, 
AF_INET
,

1802 
UDP_TABLE_OWNER_PID
, 0) == 0)

1804 
udp4TabË
 = 
bË
;

1806 
i
 = 0; i < 
udp4TabË
->
dwNumEÁr›s
; i++)

1808 ià(
pid
 != -1) {

1809 ià(
udp4TabË
->
bË
[
i
].
dwOwnšgPid
 !ð
pid
) {

1814 ià(
udp4TabË
->
bË
[
i
].
dwLoÿlAddr
 != 0 ||

1815 
udp4TabË
->
bË
[
i
].
dwLoÿlPÜt
 != 0)

1817 
š_addr
 
addr
;

1819 
addr
.
S_un
.
S_addr
 = 
udp4TabË
->
bË
[
i
].
dwLoÿlAddr
;

1820 
	`¹lIpv4Add»ssToSŒšgA
(&
addr
, 
add»ssBufãrLoÿl
);

1821 
add»ssTu¶eLoÿl
 = 
	`Py_BuždV®ue
(

1823 
add»ssBufãrLoÿl
,

1824 
	`BYTESWAP_USHORT
(
udp4TabË
->
bË
[
i
].
dwLoÿlPÜt
));

1827 
add»ssTu¶eLoÿl
 = 
	`PyTu¶e_New
(0);

1830 ià(
add»ssTu¶eLoÿl
 =ð
NULL
)

1831 
”rÜ
;

1833 
cÚÃùiÚTu¶e
 = 
	`Py_BuždV®ue
(

1836 
AF_INET
,

1837 
SOCK_DGRAM
,

1838 
add»ssTu¶eLoÿl
,

1839 
	`PyTu¶e_New
(0),

1840 
PSUTIL_CONN_NONE
,

1841 
udp4TabË
->
bË
[
i
].
dwOwnšgPid
);

1842 ià(!
cÚÃùiÚTu¶e
)

1843 
”rÜ
;

1844 ià(
	`PyLi¡_Aµ’d
(
cÚÃùiÚsLi¡
, 
cÚÃùiÚTu¶e
))

1845 
”rÜ
;

1846 
	`Py_DECREF
(
cÚÃùiÚTu¶e
);

1850 
	`ä“
(
bË
);

1855 ià((
	`PySequ’û_Cڏšs
(
af_fž‹r
, 
_AF_INET6
) == 1) &&

1856 (
	`PySequ’û_Cڏšs
(
ty³_fž‹r
, 
_SOCK_DGRAM
) == 1))

1858 
bË
 = 
NULL
;

1859 
cÚÃùiÚTu¶e
 = 
NULL
;

1860 
add»ssTu¶eLoÿl
 = 
NULL
;

1861 
add»ssTu¶eRemÙe
 = 
NULL
;

1862 
bËSize
 = 0;

1863 
	`g‘Ex‹ndedUdpTabË
(
NULL
, &
bËSize
, 
FALSE
,

1864 
AF_INET6
, 
UDP_TABLE_OWNER_PID
, 0);

1866 
bË
 = 
	`m®loc
(
bËSize
);

1867 ià(
bË
 =ð
NULL
) {

1868 
	`PyE¼_NoMemÜy
();

1869 
”rÜ
;

1872 ià(
	`g‘Ex‹ndedUdpTabË
(
bË
, &
bËSize
, 
FALSE
, 
AF_INET6
,

1873 
UDP_TABLE_OWNER_PID
, 0) == 0)

1875 
udp6TabË
 = 
bË
;

1877 
i
 = 0; i < 
udp6TabË
->
dwNumEÁr›s
; i++)

1879 ià(
pid
 != -1) {

1880 ià(
udp6TabË
->
bË
[
i
].
dwOwnšgPid
 !ð
pid
) {

1885 ià(
	`memcmp
(
udp6TabË
->
bË
[
i
].
ucLoÿlAddr
, 
nuÎ_add»ss
, 16)

1886 !ð0 || 
udp6TabË
->
bË
[
i
].
dwLoÿlPÜt
 != 0)

1888 
š6_addr
 
addr
;

1890 
	`memýy
(&
addr
, 
udp6TabË
->
bË
[
i
].
ucLoÿlAddr
, 16);

1891 
	`¹lIpv6Add»ssToSŒšgA
(&
addr
, 
add»ssBufãrLoÿl
);

1892 
add»ssTu¶eLoÿl
 = 
	`Py_BuždV®ue
(

1894 
add»ssBufãrLoÿl
,

1895 
	`BYTESWAP_USHORT
(
udp6TabË
->
bË
[
i
].
dwLoÿlPÜt
));

1898 
add»ssTu¶eLoÿl
 = 
	`PyTu¶e_New
(0);

1901 ià(
add»ssTu¶eLoÿl
 =ð
NULL
)

1902 
”rÜ
;

1904 
cÚÃùiÚTu¶e
 = 
	`Py_BuždV®ue
(

1907 
AF_INET6
,

1908 
SOCK_DGRAM
,

1909 
add»ssTu¶eLoÿl
,

1910 
	`PyTu¶e_New
(0),

1911 
PSUTIL_CONN_NONE
,

1912 
udp6TabË
->
bË
[
i
].
dwOwnšgPid
);

1913 ià(!
cÚÃùiÚTu¶e
)

1914 
”rÜ
;

1915 ià(
	`PyLi¡_Aµ’d
(
cÚÃùiÚsLi¡
, 
cÚÃùiÚTu¶e
))

1916 
”rÜ
;

1917 
	`Py_DECREF
(
cÚÃùiÚTu¶e
);

1921 
	`ä“
(
bË
);

1924 
	`_psutž_cÚn_deüef_objs
();

1925  
cÚÃùiÚsLi¡
;

1927 
”rÜ
:

1928 
	`_psutž_cÚn_deüef_objs
();

1929 
	`Py_XDECREF
(
cÚÃùiÚTu¶e
);

1930 
	`Py_XDECREF
(
add»ssTu¶eLoÿl
);

1931 
	`Py_XDECREF
(
add»ssTu¶eRemÙe
);

1932 
	`Py_DECREF
(
cÚÃùiÚsLi¡
);

1933 ià(
bË
 !ð
NULL
)

1934 
	`ä“
(
bË
);

1935  
NULL
;

1936 
	}
}

1942 
PyObjeù
 *

1943 
	$psutž_´oc_´iÜ™y_g‘
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1945 
pid
;

1946 
DWORD
 
´iÜ™y
;

1947 
HANDLE
 
hProûss
;

1948 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

1949  
NULL
;

1952 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

1953 ià(
hProûss
 =ð
NULL
) {

1954  
NULL
;

1957 
´iÜ™y
 = 
	`G‘PriÜ™yCÏss
(
hProûss
);

1958 
	`Clo£HªdË
(
hProûss
);

1959 ià(
´iÜ™y
 == 0) {

1960 
	`PyE¼_S‘FromWšdowsE¼
(0);

1961  
NULL
;

1963  
	`Py_BuždV®ue
("i", 
´iÜ™y
);

1964 
	}
}

1970 
PyObjeù
 *

1971 
	$psutž_´oc_´iÜ™y_£t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

1973 
pid
;

1974 
´iÜ™y
;

1975 
»tv®
;

1976 
HANDLE
 
hProûss
;

1977 
DWORD
 
dwDesœedAcûss
 = \

1978 
PROCESS_QUERY_INFORMATION
 | 
PROCESS_SET_INFORMATION
;

1979 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "li", &
pid
, &
´iÜ™y
)) {

1980  
NULL
;

1983 
hProûss
 = 
	`psutž_hªdË_äom_pid_wacûss
(
pid
, 
dwDesœedAcûss
);

1984 ià(
hProûss
 =ð
NULL
) {

1985  
NULL
;

1988 
»tv®
 = 
	`S‘PriÜ™yCÏss
(
hProûss
, 
´iÜ™y
);

1989 
	`Clo£HªdË
(
hProûss
);

1990 ià(
»tv®
 == 0) {

1991 
	`PyE¼_S‘FromWšdowsE¼
(0);

1992  
NULL
;

1994 
	`Py_INCREF
(
Py_NÚe
);

1995  
Py_NÚe
;

1996 
	}
}

1999 #ià(
_WIN32_WINNT
 >= 0x0600)

2003 
PyObjeù
 *

2004 
	$psutž_´oc_io_´iÜ™y_g‘
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2006 
pid
;

2007 
HANDLE
 
hProûss
;

2008 
PULONG
 
IoPriܙy
;

2010 
_NtQu”yInfÜm©iÚProûss
 
NtQu”yInfÜm©iÚProûss
 =

2011 (
_NtQu”yInfÜm©iÚProûss
)
	`G‘ProcAdd»ss
(

2012 
	`G‘ModuËHªdËA
("ntdll.dll"), "NtQueryInformationProcess");

2014 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2015  
NULL
;

2017 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

2018 ià(
hProûss
 =ð
NULL
) {

2019  
NULL
;

2022 
	`NtQu”yInfÜm©iÚProûss
(

2023 
hProûss
,

2024 
ProûssIoPriÜ™y
,

2025 &
IoPriܙy
,

2026 (
ULONG
),

2027 
NULL


2029 
	`Clo£HªdË
(
hProûss
);

2030  
	`Py_BuždV®ue
("i", 
IoPriܙy
);

2031 
	}
}

2037 
PyObjeù
 *

2038 
	$psutž_´oc_io_´iÜ™y_£t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2040 
pid
;

2041 
´io
;

2042 
HANDLE
 
hProûss
;

2044 
_NtS‘InfÜm©iÚProûss
 
NtS‘InfÜm©iÚProûss
 =

2045 (
_NtS‘InfÜm©iÚProûss
)
	`G‘ProcAdd»ss
(

2046 
	`G‘ModuËHªdËA
("ntdll.dll"), "NtSetInformationProcess");

2048 ià(
NtS‘InfÜm©iÚProûss
 =ð
NULL
) {

2049 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
,

2051  
NULL
;

2054 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "li", &
pid
, &
´io
)) {

2055  
NULL
;

2057 
hProûss
 = 
	`psutž_hªdË_äom_pid_wacûss
(
pid
, 
PROCESS_ALL_ACCESS
);

2058 ià(
hProûss
 =ð
NULL
) {

2059  
NULL
;

2062 
	`NtS‘InfÜm©iÚProûss
(

2063 
hProûss
,

2064 
ProûssIoPriÜ™y
,

2065 (
PVOID
)&
´io
,

2066 ((
PVOID
)
´io
)

2069 
	`Clo£HªdË
(
hProûss
);

2070 
	`Py_INCREF
(
Py_NÚe
);

2071  
Py_NÚe
;

2072 
	}
}

2079 
PyObjeù
 *

2080 
	$psutž_´oc_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2082 
DWORD
 
pid
;

2083 
HANDLE
 
hProûss
;

2084 
IO_COUNTERS
 
IoCouÁ”s
;

2086 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2087  
NULL
;

2089 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

2090 ià(
NULL
 =ð
hProûss
) {

2091  
NULL
;

2093 ià(! 
	`G‘ProûssIoCouÁ”s
(
hProûss
, &
IoCouÁ”s
)) {

2094 
	`Clo£HªdË
(
hProûss
);

2095  
	`PyE¼_S‘FromWšdowsE¼
(0);

2097 
	`Clo£HªdË
(
hProûss
);

2098  
	`Py_BuždV®ue
("(KKKK)",

2099 
IoCouÁ”s
.
R—dO³¿tiÚCouÁ
,

2100 
IoCouÁ”s
.
Wr™eO³¿tiÚCouÁ
,

2101 
IoCouÁ”s
.
R—dT¿nsãrCouÁ
,

2102 
IoCouÁ”s
.
Wr™eT¿nsãrCouÁ
);

2103 
	}
}

2109 
PyObjeù
 *

2110 
	$psutž_´oc_io_couÁ”s_2
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2112 
DWORD
 
pid
;

2113 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

2114 
PVOID
 
bufãr
;

2115 
LONGLONG
 
rcouÁ
, 
wcouÁ
, 
rby‹s
, 
wby‹s
;

2117 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2118  
NULL
;

2120 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

2121  
NULL
;

2123 
rcouÁ
 = 
´oûss
->
R—dO³¿tiÚCouÁ
.
QuadP¬t
;

2124 
wcouÁ
 = 
´oûss
->
Wr™eO³¿tiÚCouÁ
.
QuadP¬t
;

2125 
rby‹s
 = 
´oûss
->
R—dT¿nsãrCouÁ
.
QuadP¬t
;

2126 
wby‹s
 = 
´oûss
->
Wr™eT¿nsãrCouÁ
.
QuadP¬t
;

2127 
	`ä“
(
bufãr
);

2128  
	`Py_BuždV®ue
("KKKK", 
rcouÁ
, 
wcouÁ
, 
rby‹s
, 
wby‹s
);

2129 
	}
}

2135 
PyObjeù
 *

2136 
	$psutž_´oc_ýu_affš™y_g‘
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2138 
DWORD
 
pid
;

2139 
HANDLE
 
hProûss
;

2140 
PDWORD_PTR
 
´oc_mask
;

2141 
PDWORD_PTR
 
sy¡em_mask
;

2143 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2144  
NULL
;

2146 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

2147 ià(
hProûss
 =ð
NULL
) {

2148  
NULL
;

2150 ià(
	`G‘ProûssAffš™yMask
(
hProûss
, &
´oc_mask
, &
sy¡em_mask
) == 0) {

2151 
	`Clo£HªdË
(
hProûss
);

2152  
	`PyE¼_S‘FromWšdowsE¼
(0);

2155 
	`Clo£HªdË
(
hProûss
);

2156 #ifdeà
_WIN64


2157  
	`Py_BuždV®ue
("K", ()
´oc_mask
);

2159  
	`Py_BuždV®ue
("k", ()
´oc_mask
);

2161 
	}
}

2167 
PyObjeù
 *

2168 
	$psutž_´oc_ýu_affš™y_£t
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2170 
DWORD
 
pid
;

2171 
HANDLE
 
hProûss
;

2172 
DWORD
 
dwDesœedAcûss
 = \

2173 
PROCESS_QUERY_INFORMATION
 | 
PROCESS_SET_INFORMATION
;

2174 
DWORD_PTR
 
mask
;

2176 #ifdeà
_WIN64


2177 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lK", &
pid
, &
mask
))

2179 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "lk", &
pid
, &
mask
))

2182  
NULL
;

2184 
hProûss
 = 
	`psutž_hªdË_äom_pid_wacûss
(
pid
, 
dwDesœedAcûss
);

2185 ià(
hProûss
 =ð
NULL
) {

2186  
NULL
;

2189 ià(
	`S‘ProûssAffš™yMask
(
hProûss
, 
mask
) == 0) {

2190 
	`Clo£HªdË
(
hProûss
);

2191  
	`PyE¼_S‘FromWšdowsE¼
(0);

2194 
	`Clo£HªdË
(
hProûss
);

2195 
	`Py_INCREF
(
Py_NÚe
);

2196  
Py_NÚe
;

2197 
	}
}

2204 
PyObjeù
 *

2205 
	$psutž_´oc_is_su¥’ded
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2207 
DWORD
 
pid
;

2208 
ULONG
 
i
;

2209 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

2210 
PVOID
 
bufãr
;

2212 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2213  
NULL
;

2215 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

2216  
NULL
;

2218 
i
 = 0; i < 
´oûss
->
Numb”OfTh»ads
; i++) {

2219 ià(
´oûss
->
Th»ads
[
i
].
Th»adS‹
 !ð
Wa™šg
 ||

2220 
´oûss
->
Th»ads
[
i
].
Wa™R—sÚ
 !ð
Su¥’ded
)

2222 
	`ä“
(
bufãr
);

2223 
Py_RETURN_FALSE
;

2226 
	`ä“
(
bufãr
);

2227 
Py_RETURN_TRUE
;

2228 
	}
}

2234 
PyObjeù
 *

2235 
	$psutž_disk_u§ge
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2237 
BOOL
 
»tv®
;

2238 
ULARGE_INTEGER
 
_
, 
tÙ®
, 
ä“
;

2239 *
·th
;

2241 ià(
	`PyArg_P¬£Tu¶e
(
¬gs
, "u", &
·th
)) {

2242 
Py_BEGIN_ALLOW_THREADS


2243 
»tv®
 = 
	`G‘DiskF»eS·ûExW
((
LPCWSTR
)
·th
, &
_
, &
tÙ®
, &
ä“
);

2244 
Py_END_ALLOW_THREADS


2245 
»tuº_
;

2250 #ià
PY_MAJOR_VERSION
 <= 2

2251 
	`PyE¼_Cˬ
();

2252 ià(
	`PyArg_P¬£Tu¶e
(
¬gs
, "s", &
·th
)) {

2253 
Py_BEGIN_ALLOW_THREADS


2254 
»tv®
 = 
	`G‘DiskF»eS·ûEx
(
·th
, &
_
, &
tÙ®
, &
ä“
);

2255 
Py_END_ALLOW_THREADS


2256 
»tuº_
;

2260  
NULL
;

2262 
»tuº_
:

2263 ià(
»tv®
 == 0)

2264  
	`PyE¼_S‘FromWšdowsE¼
(0);

2266  
	`Py_BuždV®ue
("(LL)", 
tÙ®
.
QuadP¬t
, 
ä“
.QuadPart);

2267 
	}
}

2273 
PyObjeù
 *

2274 
	$psutž_Ãt_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2276 
©‹m±s
 = 0;

2277 
i
;

2278 
outBufL’
 = 15000;

2279 
iâame
[
MAX_PATH
];

2280 
DWORD
 
dwR‘V®
 = 0;

2281 
MIB_IFROW
 *
pIfRow
 = 
NULL
;

2282 
ULONG
 
æags
 = 0;

2283 
ULONG
 
çmžy
 = 
AF_UNSPEC
;

2284 
PIP_ADAPTER_ADDRESSES
 
pAdd»s£s
 = 
NULL
;

2285 
PIP_ADAPTER_ADDRESSES
 
pCu¼Add»s£s
 = 
NULL
;

2287 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

2288 
PyObjeù
 *
py_nic_šfo
 = 
NULL
;

2289 
PyObjeù
 *
py_nic_Çme
 = 
NULL
;

2291 ià(
py_»tdiù
 =ð
NULL
) {

2292  
NULL
;

2295 
pAdd»s£s
 = (
IP_ADAPTER_ADDRESSES
 *è
	`m®loc
(
outBufL’
);

2296 ià(
pAdd»s£s
 =ð
NULL
) {

2297 
	`PyE¼_NoMemÜy
();

2298 
”rÜ
;

2301 
dwR‘V®
 = 
	`G‘Ad­‹rsAdd»s£s
(
çmžy
, 
æags
, 
NULL
, 
pAdd»s£s
,

2302 &
outBufL’
);

2303 ià(
dwR‘V®
 =ð
ERROR_BUFFER_OVERFLOW
) {

2304 
	`ä“
(
pAdd»s£s
);

2305 
pAdd»s£s
 = 
NULL
;

2311 
©‹m±s
++;

2312 } (
dwR‘V®
 =ð
ERROR_BUFFER_OVERFLOW
è&& (
©‹m±s
 < 3));

2314 ià(
dwR‘V®
 !ð
NO_ERROR
) {

2315 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "GetAdaptersAddresses() failed.");

2316 
”rÜ
;

2319 
pCu¼Add»s£s
 = 
pAdd»s£s
;

2320 
pCu¼Add»s£s
) {

2321 
py_nic_Çme
 = 
NULL
;

2322 
py_nic_šfo
 = 
NULL
;

2323 
pIfRow
 = (
MIB_IFROW
 *è
	`m®loc
((MIB_IFROW));

2325 ià(
pIfRow
 =ð
NULL
) {

2326 
	`PyE¼_NoMemÜy
();

2327 
”rÜ
;

2330 
pIfRow
->
dwIndex
 = 
pCu¼Add»s£s
->
IfIndex
;

2331 
dwR‘V®
 = 
	`G‘IfEÁry
(
pIfRow
);

2332 ià(
dwR‘V®
 !ð
NO_ERROR
) {

2333 
	`PyE¼_S‘SŒšg
(
PyExc_RuÁimeE¼Ü
, "GetIfEntry() failed.");

2334 
”rÜ
;

2337 
py_nic_šfo
 = 
	`Py_BuždV®ue
("(kkkkkkkk)",

2338 
pIfRow
->
dwOutOù‘s
,

2339 
pIfRow
->
dwInOù‘s
,

2340 
pIfRow
->
dwOutUÿ¡Pkts
,

2341 
pIfRow
->
dwInUÿ¡Pkts
,

2342 
pIfRow
->
dwInE¼Üs
,

2343 
pIfRow
->
dwOutE¼Üs
,

2344 
pIfRow
->
dwInDisÿrds
,

2345 
pIfRow
->
dwOutDisÿrds
);

2346 ià(!
py_nic_šfo
)

2347 
”rÜ
;

2349 
	`¥rštf
(
iâame
, "%wS", 
pCu¼Add»s£s
->
Fr›ndlyName
);

2351 #ià
PY_MAJOR_VERSION
 >= 3

2354 
i
 = 0; i < 
MAX_PATH
; i++) {

2355 ià(*(
iâame
+
i
) < 0 || *(ifname+i) > 256) {

2357 *(
iâame
+
i
) = '?';

2359 ià(*(
iâame
+
i
) == '\0') {

2364 
py_nic_Çme
 = 
	`Py_BuždV®ue
("s", 
iâame
);

2365 ià(
py_nic_Çme
 =ð
NULL
)

2366 
”rÜ
;

2367 ià(
	`PyDiù_S‘I‹m
(
py_»tdiù
, 
py_nic_Çme
, 
py_nic_šfo
))

2368 
”rÜ
;

2369 
	`Py_XDECREF
(
py_nic_Çme
);

2370 
	`Py_XDECREF
(
py_nic_šfo
);

2372 
	`ä“
(
pIfRow
);

2373 
pCu¼Add»s£s
 =…Cu¼Add»s£s->
Next
;

2376 
	`ä“
(
pAdd»s£s
);

2377  
py_»tdiù
;

2379 
”rÜ
:

2380 
	`Py_XDECREF
(
py_nic_Çme
);

2381 
	`Py_XDECREF
(
py_nic_šfo
);

2382 
	`Py_DECREF
(
py_»tdiù
);

2383 ià(
pAdd»s£s
 !ð
NULL
)

2384 
	`ä“
(
pAdd»s£s
);

2385 ià(
pIfRow
 !ð
NULL
)

2386 
	`ä“
(
pIfRow
);

2387  
NULL
;

2388 
	}
}

2392 
	s_DISK_PERFORMANCE_WIN_2008
 {

2393 
LARGE_INTEGER
 
	mBy‹sR—d
;

2394 
LARGE_INTEGER
 
	mBy‹sWr™‹n
;

2395 
LARGE_INTEGER
 
	mR—dTime
;

2396 
LARGE_INTEGER
 
	mWr™eTime
;

2397 
LARGE_INTEGER
 
	mIdËTime
;

2398 
DWORD
 
	mR—dCouÁ
;

2399 
DWORD
 
	mWr™eCouÁ
;

2400 
DWORD
 
	mQueueD•th
;

2401 
DWORD
 
	mS¶™CouÁ
;

2402 
LARGE_INTEGER
 
	mQu”yTime
;

2403 
DWORD
 
	mStÜageDeviûNumb”
;

2404 
WCHAR
 
	mStÜageMªag”Name
[8];

2405 } 
	tDISK_PERFORMANCE_WIN_2008
;

2410 
PyObjeù
 *

2411 
	$psutž_disk_io_couÁ”s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2413 
DISK_PERFORMANCE_WIN_2008
 
diskP”fÜmªû
;

2414 
DWORD
 
dwSize
;

2415 
HANDLE
 
hDeviû
 = 
NULL
;

2416 
szDeviû
[
MAX_PATH
];

2417 
szDeviûDi¥Ïy
[
MAX_PATH
];

2418 
devNum
;

2419 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

2420 
PyObjeù
 *
py_disk_šfo
 = 
NULL
;

2421 ià(
py_»tdiù
 =ð
NULL
) {

2422  
NULL
;

2429 
devNum
 = 0; devNum <= 32; ++devNum) {

2430 
py_disk_šfo
 = 
NULL
;

2431 
	`¥rštf
(
szDeviû
, "\\\\.\\PhysiÿlDrive%d", 
devNum
);

2432 
hDeviû
 = 
	`C»©eFže
(
szDeviû
, 0, 
FILE_SHARE_READ
 | 
FILE_SHARE_WRITE
,

2433 
NULL
, 
OPEN_EXISTING
, 0, NULL);

2435 ià(
hDeviû
 =ð
INVALID_HANDLE_VALUE
) {

2438 ià(
	`DeviûIoCÚŒÞ
(
hDeviû
, 
IOCTL_DISK_PERFORMANCE
, 
NULL
, 0,

2439 &
diskP”fÜmªû
, (diskPerformance),

2440 &
dwSize
, 
NULL
))

2442 
	`¥rštf
(
szDeviûDi¥Ïy
, "PhysiÿlDrive%d", 
devNum
);

2443 
py_disk_šfo
 = 
	`Py_BuždV®ue
(

2445 
diskP”fÜmªû
.
R—dCouÁ
,

2446 
diskP”fÜmªû
.
Wr™eCouÁ
,

2447 
diskP”fÜmªû
.
By‹sR—d
,

2448 
diskP”fÜmªû
.
By‹sWr™‹n
,

2449 (
diskP”fÜmªû
.
R—dTime
.
QuadP¬t
 * 10) / 1000,

2450 (
diskP”fÜmªû
.
Wr™eTime
.
QuadP¬t
 * 10) / 1000);

2451 ià(!
py_disk_šfo
)

2452 
”rÜ
;

2453 ià(
	`PyDiù_S‘I‹mSŒšg
(
py_»tdiù
, 
szDeviûDi¥Ïy
,

2454 
py_disk_šfo
))

2456 
”rÜ
;

2458 
	`Py_XDECREF
(
py_disk_šfo
);

2467 
	`Clo£HªdË
(
hDeviû
);

2470  
py_»tdiù
;

2472 
”rÜ
:

2473 
	`Py_XDECREF
(
py_disk_šfo
);

2474 
	`Py_DECREF
(
py_»tdiù
);

2475 ià(
hDeviû
 !ð
NULL
)

2476 
	`Clo£HªdË
(
hDeviû
);

2477  
NULL
;

2478 
	}
}

2481 *
	$psutž_g‘_drive_ty³
(
ty³
)

2483 
ty³
) {

2484 
DRIVE_FIXED
:

2486 
DRIVE_CDROM
:

2488 
DRIVE_REMOVABLE
:

2490 
DRIVE_UNKNOWN
:

2492 
DRIVE_NO_ROOT_DIR
:

2494 
DRIVE_REMOTE
:

2496 
DRIVE_RAMDISK
:

2501 
	}
}

2504 #iâdeà
_ARRAYSIZE


2505 

	#_ARRAYSIZE
(
a
è(×)/×[0]))

	)

2512 
PyObjeù
 *

2513 
	$psutž_disk_·¹™iÚs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2515 
DWORD
 
num_by‹s
;

2516 
drive_¡ršgs
[255];

2517 *
drive_ˉ”
 = 
drive_¡ršgs
;

2518 
®l
;

2519 
ty³
;

2520 
»t
;

2521 
Ýts
[20];

2522 
LPTSTR
 
fs_ty³
[
MAX_PATH
 + 1] = { 0 };

2523 
DWORD
 
pæags
 = 0;

2524 
PyObjeù
 *
py_®l
;

2525 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

2526 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

2528 ià(
py_»Ži¡
 =ð
NULL
) {

2529  
NULL
;

2534 
	`S‘E¼ÜMode
(
SEM_FAILCRITICALERRORS
);

2536 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "O", &
py_®l
)) {

2537 
”rÜ
;

2539 
®l
 = 
	`PyObjeù_IsTrue
(
py_®l
);

2541 
Py_BEGIN_ALLOW_THREADS


2542 
num_by‹s
 = 
	`G‘LogiÿlDriveSŒšgs
(254, 
drive_ˉ”
);

2543 
Py_END_ALLOW_THREADS


2545 ià(
num_by‹s
 == 0) {

2546 
	`PyE¼_S‘FromWšdowsE¼
(0);

2547 
”rÜ
;

2550 *
drive_ˉ”
 != 0) {

2551 
py_tu¶e
 = 
NULL
;

2552 
Ýts
[0] = 0;

2553 
fs_ty³
[0] = 0;

2555 
Py_BEGIN_ALLOW_THREADS


2556 
ty³
 = 
	`G‘DriveTy³
(
drive_ˉ”
);

2557 
Py_END_ALLOW_THREADS


2560 ià(
®l
 == 0) {

2561 ià((
ty³
 =ð
DRIVE_UNKNOWN
) ||

2562 (
ty³
 =ð
DRIVE_NO_ROOT_DIR
) ||

2563 (
ty³
 =ð
DRIVE_REMOTE
) ||

2564 (
ty³
 =ð
DRIVE_RAMDISK
)) {

2565 
Ãxt
;

2569 ià((
ty³
 =ð
DRIVE_REMOVABLE
) &&

2570 (
	`¡rcmp
(
drive_ˉ”
, "A:\\") == 0)) {

2571 
Ãxt
;

2575 
»t
 = 
	`G‘VÞumeInfÜm©iÚ
(

2576 (
LPCTSTR
)
drive_ˉ”
, 
NULL
, 
	`_ARRAYSIZE
(drive_letter),

2577 
NULL
, NULL, &
pæags
, (
LPTSTR
)
fs_ty³
, 
	`_ARRAYSIZE
(fs_type));

2578 ià(
»t
 == 0) {

2583 
	`¡rÿt
(
Ýts
, "");

2584 
	`S‘La¡E¼Ü
(0);

2587 ià(
pæags
 & 
FILE_READ_ONLY_VOLUME
) {

2588 
	`¡rÿt
(
Ýts
, "ro");

2591 
	`¡rÿt
(
Ýts
, "rw");

2593 ià(
pæags
 & 
FILE_VOLUME_IS_COMPRESSED
) {

2594 
	`¡rÿt
(
Ýts
, ",compressed");

2598 ià(
	`¡¾’
(
Ýts
) > 0) {

2599 
	`¡rÿt
(
Ýts
, ",");

2601 
	`¡rÿt
(
Ýts
, 
	`psutž_g‘_drive_ty³
(
ty³
));

2603 
py_tu¶e
 = 
	`Py_BuždV®ue
(

2605 
drive_ˉ”
,

2606 
drive_ˉ”
,

2607 
fs_ty³
,

2608 
Ýts
);

2609 ià(!
py_tu¶e
)

2610 
”rÜ
;

2611 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

2612 
”rÜ
;

2613 
	`Py_DECREF
(
py_tu¶e
);

2614 
Ãxt
;

2616 
Ãxt
:

2617 
drive_ˉ”
 = 
	`¡rchr
(drive_letter, 0) + 1;

2620 
	`S‘E¼ÜMode
(0);

2621  
py_»Ži¡
;

2623 
”rÜ
:

2624 
	`S‘E¼ÜMode
(0);

2625 
	`Py_XDECREF
(
py_tu¶e
);

2626 
	`Py_DECREF
(
py_»Ži¡
);

2627  
NULL
;

2628 
	}
}

2631 #ifdeà
UNICODE


2632 

	#WTSO³nS”v”
 
WTSO³nS”v”W


	)

2634 

	#WTSO³nS”v”
 
WTSO³nS”v”A


	)

2641 
PyObjeù
 *

2642 
	$psutž_u£rs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2644 
HANDLE
 
hS”v”
 = 
NULL
;

2645 
LPTSTR
 
bufãr_u£r
 = 
NULL
;

2646 
LPTSTR
 
bufãr_addr
 = 
NULL
;

2647 
PWTS_SESSION_INFO
 
£ssiÚs
 = 
NULL
;

2648 
DWORD
 
couÁ
;

2649 
DWORD
 
i
;

2650 
DWORD
 
£ssiÚId
;

2651 
DWORD
 
by‹s
;

2652 
PWTS_CLIENT_ADDRESS
 
add»ss
;

2653 
add»ss_¡r
[50];

2654 
unix_time
;

2656 
PWINSTATIONQUERYINFORMATIONW
 
WšStiÚQu”yInfÜm©iÚW
;

2657 
WINSTATION_INFO
 
¡©iÚ_šfo
;

2658 
HINSTANCE
 
hIn¡WšS
 = 
NULL
;

2659 
ULONG
 
»tuºL’
;

2661 
PyObjeù
 *
py_»Ži¡
 = 
	`PyLi¡_New
(0);

2662 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

2663 
PyObjeù
 *
py_add»ss
 = 
NULL
;

2664 ià(
py_»Ži¡
 =ð
NULL
) {

2665  
NULL
;

2668 
hIn¡WšS
 = 
	`LßdLib¿ryA
("winsta.dll");

2669 
WšStiÚQu”yInfÜm©iÚW
 = (
PWINSTATIONQUERYINFORMATIONW
) \

2670 
	`G‘ProcAdd»ss
(
hIn¡WšS
, "WinStationQueryInformationW");

2672 
hS”v”
 = 
	`WTSO³nS”v”
('\0');

2673 ià(
hS”v”
 =ð
NULL
) {

2674 
	`PyE¼_S‘FromWšdowsE¼
(0);

2675 
”rÜ
;

2678 ià(
	`WTSEnum”©eSessiÚs
(
hS”v”
, 0, 1, &
£ssiÚs
, &
couÁ
) == 0) {

2679 
	`PyE¼_S‘FromWšdowsE¼
(0);

2680 
”rÜ
;

2683 
i
 = 0; i < 
couÁ
; i++) {

2684 
py_add»ss
 = 
NULL
;

2685 
py_tu¶e
 = 
NULL
;

2686 
£ssiÚId
 = 
£ssiÚs
[
i
].
SessiÚId
;

2687 ià(
bufãr_u£r
 !ð
NULL
) {

2688 
	`WTSF»eMemÜy
(
bufãr_u£r
);

2690 ià(
bufãr_addr
 !ð
NULL
) {

2691 
	`WTSF»eMemÜy
(
bufãr_addr
);

2694 
bufãr_u£r
 = 
NULL
;

2695 
bufãr_addr
 = 
NULL
;

2698 
by‹s
 = 0;

2699 ià(
	`WTSQu”ySessiÚInfÜm©iÚ
(
hS”v”
, 
£ssiÚId
, 
WTSU£rName
,

2700 &
bufãr_u£r
, &
by‹s
) == 0) {

2701 
	`PyE¼_S‘FromWšdowsE¼
(0);

2702 
”rÜ
;

2704 ià(
by‹s
 == 1) {

2709 
by‹s
 = 0;

2710 ià(
	`WTSQu”ySessiÚInfÜm©iÚ
(
hS”v”
, 
£ssiÚId
, 
WTSCl›ÁAdd»ss
,

2711 &
bufãr_addr
, &
by‹s
) == 0) {

2712 
	`PyE¼_S‘FromWšdowsE¼
(0);

2713 
”rÜ
;

2716 
add»ss
 = (
PWTS_CLIENT_ADDRESS
)
bufãr_addr
;

2717 ià(
add»ss
->
Add»ssFamžy
 == 0) {

2718 
	`¥rštf
(
add»ss_¡r
,

2720 
add»ss
->
Add»ss
[0],

2721 
add»ss
->
Add»ss
[1],

2722 
add»ss
->
Add»ss
[2],

2723 
add»ss
->
Add»ss
[3]);

2724 
py_add»ss
 = 
	`Py_BuždV®ue
("s", 
add»ss_¡r
);

2725 ià(!
py_add»ss
)

2726 
”rÜ
;

2729 
py_add»ss
 = 
Py_NÚe
;

2733 ià(!
	`WšStiÚQu”yInfÜm©iÚW
(
hS”v”
,

2734 
£ssiÚId
,

2735 
WšStiÚInfÜm©iÚ
,

2736 &
¡©iÚ_šfo
,

2737 (
¡©iÚ_šfo
),

2738 &
»tuºL’
))

2740 
”rÜ
;

2743 
unix_time
 = ((
LONGLONG
)
¡©iÚ_šfo
.
CÚÃùTime
.
dwHighD©eTime
) << 32;

2744 
unix_time
 += \

2745 
¡©iÚ_šfo
.
CÚÃùTime
.
dwLowD©eTime
 - 116444736000000000LL;

2746 
unix_time
 /= 10000000;

2748 
py_tu¶e
 = 
	`Py_BuždV®ue
("sOd", 
bufãr_u£r
, 
py_add»ss
,

2749 ()
unix_time
);

2750 ià(!
py_tu¶e
)

2751 
”rÜ
;

2752 ià(
	`PyLi¡_Aµ’d
(
py_»Ži¡
, 
py_tu¶e
))

2753 
”rÜ
;

2754 
	`Py_XDECREF
(
py_add»ss
);

2755 
	`Py_XDECREF
(
py_tu¶e
);

2758 
	`WTSClo£S”v”
(
hS”v”
);

2759 
	`WTSF»eMemÜy
(
£ssiÚs
);

2760 
	`WTSF»eMemÜy
(
bufãr_u£r
);

2761 
	`WTSF»eMemÜy
(
bufãr_addr
);

2762 
	`F»eLib¿ry
(
hIn¡WšS
);

2763  
py_»Ži¡
;

2765 
”rÜ
:

2766 
	`Py_XDECREF
(
py_tu¶e
);

2767 
	`Py_XDECREF
(
py_add»ss
);

2768 
	`Py_DECREF
(
py_»Ži¡
);

2770 ià(
hIn¡WšS
 !ð
NULL
) {

2771 
	`F»eLib¿ry
(
hIn¡WšS
);

2773 ià(
hS”v”
 !ð
NULL
) {

2774 
	`WTSClo£S”v”
(
hS”v”
);

2776 ià(
£ssiÚs
 !ð
NULL
) {

2777 
	`WTSF»eMemÜy
(
£ssiÚs
);

2779 ià(
bufãr_u£r
 !ð
NULL
) {

2780 
	`WTSF»eMemÜy
(
bufãr_u£r
);

2782 ià(
bufãr_addr
 !ð
NULL
) {

2783 
	`WTSF»eMemÜy
(
bufãr_addr
);

2785  
NULL
;

2786 
	}
}

2792 
PyObjeù
 *

2793 
	$psutž_´oc_num_hªdËs
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2795 
DWORD
 
pid
;

2796 
HANDLE
 
hProûss
;

2797 
DWORD
 
hªdËCouÁ
;

2799 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2800  
NULL
;

2802 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

2803 ià(
NULL
 =ð
hProûss
) {

2804  
NULL
;

2806 ià(! 
	`G‘ProûssHªdËCouÁ
(
hProûss
, &
hªdËCouÁ
)) {

2807 
	`Clo£HªdË
(
hProûss
);

2808  
	`PyE¼_S‘FromWšdowsE¼
(0);

2810 
	`Clo£HªdË
(
hProûss
);

2811  
	`Py_BuždV®ue
("k", 
hªdËCouÁ
);

2812 
	}
}

2818 
PyObjeù
 *

2819 
	$psutž_´oc_num_hªdËs_2
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2821 
DWORD
 
pid
;

2822 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

2823 
PVOID
 
bufãr
;

2824 
ULONG
 
couÁ
;

2826 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2827  
NULL
;

2829 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

2830  
NULL
;

2832 
couÁ
 = 
´oûss
->
HªdËCouÁ
;

2833 
	`ä“
(
bufãr
);

2834  
	`Py_BuždV®ue
("k", 
couÁ
);

2835 
	}
}

2841 
PyObjeù
 *

2842 
	$psutž_´oc_num_ùx_sw™ches
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2844 
DWORD
 
pid
;

2845 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

2846 
PVOID
 
bufãr
;

2847 
ULONG
 
i
;

2848 
ULONG
 
tÙ®
 = 0;

2850 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2851  
NULL
;

2853 ià(! 
	`psutž_g‘_´oc_šfo
(
pid
, &
´oûss
, &
bufãr
)) {

2854  
NULL
;

2856 
i
 = 0; i < 
´oûss
->
Numb”OfTh»ads
; i++) {

2857 
tÙ®
 +ð
´oûss
->
Th»ads
[
i
].
CÚ‹xtSw™ches
;

2859 
	`ä“
(
bufãr
);

2860  
	`Py_BuždV®ue
("ki", 
tÙ®
, 0);

2861 
	}
}

2864 *
	$g‘_»giÚ_´ÙeùiÚ_¡ršg
(
ULONG
 
´ÙeùiÚ
)

2866 
´ÙeùiÚ
 & 0xff) {

2867 
PAGE_NOACCESS
:

2869 
PAGE_READONLY
:

2871 
PAGE_READWRITE
:

2873 
PAGE_WRITECOPY
:

2875 
PAGE_EXECUTE
:

2877 
PAGE_EXECUTE_READ
:

2879 
PAGE_EXECUTE_READWRITE
:

2881 
PAGE_EXECUTE_WRITECOPY
:

2886 
	}
}

2892 
PyObjeù
 *

2893 
	$psutž_´oc_memÜy_m­s
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2895 
DWORD
 
pid
;

2896 
HANDLE
 
hProûss
 = 
NULL
;

2897 
MEMORY_BASIC_INFORMATION
 
basicInfo
;

2898 
PVOID
 
ba£Add»ss
;

2899 
PVOID
 
´eviousAÎoÿtiÚBa£
;

2900 
CHAR
 
m­³dFžeName
[
MAX_PATH
];

2901 
SYSTEM_INFO
 
sy¡em_šfo
;

2902 
LPVOID
 
maxAddr
;

2903 
PyObjeù
 *
py_li¡
 = 
	`PyLi¡_New
(0);

2904 
PyObjeù
 *
py_tu¶e
 = 
NULL
;

2906 ià(
py_li¡
 =ð
NULL
) {

2907  
NULL
;

2909 ià(! 
	`PyArg_P¬£Tu¶e
(
¬gs
, "l", &
pid
)) {

2910 
”rÜ
;

2912 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

2913 ià(
NULL
 =ð
hProûss
) {

2914 
”rÜ
;

2917 
	`G‘Sy¡emInfo
(&
sy¡em_šfo
);

2918 
maxAddr
 = 
sy¡em_šfo
.
ÍMaximumAµliÿtiÚAdd»ss
;

2919 
ba£Add»ss
 = 
NULL
;

2920 
´eviousAÎoÿtiÚBa£
 = 
NULL
;

2922 
	`Vœtu®Qu”yEx
(
hProûss
, 
ba£Add»ss
, &
basicInfo
,

2923 (
MEMORY_BASIC_INFORMATION
)))

2925 
py_tu¶e
 = 
NULL
;

2926 ià(
ba£Add»ss
 > 
maxAddr
) {

2929 ià(
	`G‘M­³dFžeNameA
(
hProûss
, 
ba£Add»ss
, 
m­³dFžeName
,

2930 (
m­³dFžeName
)))

2932 
py_tu¶e
 = 
	`Py_BuždV®ue
(

2934 ()
ba£Add»ss
,

2935 
	`g‘_»giÚ_´ÙeùiÚ_¡ršg
(
basicInfo
.
PrÙeù
),

2936 
m­³dFžeName
,

2937 
basicInfo
.
RegiÚSize
);

2938 ià(!
py_tu¶e
)

2939 
”rÜ
;

2940 ià(
	`PyLi¡_Aµ’d
(
py_li¡
, 
py_tu¶e
))

2941 
”rÜ
;

2942 
	`Py_DECREF
(
py_tu¶e
);

2944 
´eviousAÎoÿtiÚBa£
 = 
basicInfo
.
AÎoÿtiÚBa£
;

2945 
ba£Add»ss
 = (
PCHAR
)ba£Add»s + 
basicInfo
.
RegiÚSize
;

2948 
	`Clo£HªdË
(
hProûss
);

2949  
py_li¡
;

2951 
”rÜ
:

2952 
	`Py_XDECREF
(
py_tu¶e
);

2953 
	`Py_DECREF
(
py_li¡
);

2954 ià(
hProûss
 !ð
NULL
)

2955 
	`Clo£HªdË
(
hProûss
);

2956  
NULL
;

2957 
	}
}

2963 
PyObjeù
 *

2964 
	$psutž_µid_m­
(
PyObjeù
 *
£lf
, PyObjeù *
¬gs
)

2966 
PyObjeù
 *
pid
 = 
NULL
;

2967 
PyObjeù
 *
µid
 = 
NULL
;

2968 
PyObjeù
 *
py_»tdiù
 = 
	`PyDiù_New
();

2969 
HANDLE
 
hªdË
 = 
NULL
;

2970 
PROCESSENTRY32
 
³
 = {0};

2971 
³
.
dwSize
 = (
PROCESSENTRY32
);

2973 ià(
py_»tdiù
 =ð
NULL
)

2974  
NULL
;

2975 
hªdË
 = 
	`C»©eToÞh–p32SÇpshÙ
(
TH32CS_SNAPPROCESS
, 0);

2976 ià(
hªdË
 =ð
INVALID_HANDLE_VALUE
) {

2977 
	`PyE¼_S‘FromWšdowsE¼
(0);

2978 
	`Py_DECREF
(
py_»tdiù
);

2979  
NULL
;

2982 ià(
	`Proûss32Fœ¡
(
hªdË
, &
³
)) {

2984 
pid
 = 
	`Py_BuždV®ue
("I", 
³
.
th32ProûssID
);

2985 ià(
pid
 =ð
NULL
)

2986 
”rÜ
;

2987 
µid
 = 
	`Py_BuždV®ue
("I", 
³
.
th32P¬’tProûssID
);

2988 ià(
µid
 =ð
NULL
)

2989 
”rÜ
;

2990 ià(
	`PyDiù_S‘I‹m
(
py_»tdiù
, 
pid
, 
µid
))

2991 
”rÜ
;

2992 
	`Py_DECREF
(
pid
);

2993 
	`Py_DECREF
(
µid
);

2994 } 
	`Proûss32Next
(
hªdË
, &
³
));

2997 
	`Clo£HªdË
(
hªdË
);

2998  
py_»tdiù
;

3000 
”rÜ
:

3001 
	`Py_XDECREF
(
pid
);

3002 
	`Py_XDECREF
(
µid
);

3003 
	`Py_DECREF
(
py_»tdiù
);

3004 
	`Clo£HªdË
(
hªdË
);

3005  
NULL
;

3006 
	}
}

3011 
PyM‘hodDef


3012 
	gPsutžM‘hods
[] =

3016 {"´oc_cmdlše", 
psutž_´oc_cmdlše
, 
METH_VARARGS
,

3018 {"´oc_exe", 
psutž_´oc_exe
, 
METH_VARARGS
,

3020 {"´oc_kžl", 
psutž_´oc_kžl
, 
METH_VARARGS
,

3022 {"´oc_ýu_times", 
psutž_´oc_ýu_times
, 
METH_VARARGS
,

3024 {"´oc_ü—‹_time", 
psutž_´oc_ü—‹_time
, 
METH_VARARGS
,

3027 {"´oc_memÜy_šfo", 
psutž_´oc_memÜy_šfo
, 
METH_VARARGS
,

3029 {"´oc_cwd", 
psutž_´oc_cwd
, 
METH_VARARGS
,

3031 {"´oc_su¥’d", 
psutž_´oc_su¥’d
, 
METH_VARARGS
,

3033 {"´oc_»sume", 
psutž_´oc_»sume
, 
METH_VARARGS
,

3035 {"´oc_Ý’_fžes", 
psutž_´oc_Ý’_fžes
, 
METH_VARARGS
,

3037 {"´oc_u£ºame", 
psutž_´oc_u£ºame
, 
METH_VARARGS
,

3039 {"´oc_num_th»ads", 
psutž_´oc_num_th»ads
, 
METH_VARARGS
,

3041 {"´oc_th»ads", 
psutž_´oc_th»ads
, 
METH_VARARGS
,

3043 {"´oc_wa™", 
psutž_´oc_wa™
, 
METH_VARARGS
,

3045 {"´oc_´iÜ™y_g‘", 
psutž_´oc_´iÜ™y_g‘
, 
METH_VARARGS
,

3047 {"´oc_´iÜ™y_£t", 
psutž_´oc_´iÜ™y_£t
, 
METH_VARARGS
,

3049 #ià(
_WIN32_WINNT
 >= 0x0600)

3050 {"´oc_io_´iÜ™y_g‘", 
psutž_´oc_io_´iÜ™y_g‘
, 
METH_VARARGS
,

3052 {"´oc_io_´iÜ™y_£t", 
psutž_´oc_io_´iÜ™y_£t
, 
METH_VARARGS
,

3055 {"´oc_ýu_affš™y_g‘", 
psutž_´oc_ýu_affš™y_g‘
, 
METH_VARARGS
,

3057 {"´oc_ýu_affš™y_£t", 
psutž_´oc_ýu_affš™y_£t
, 
METH_VARARGS
,

3059 {"´oc_io_couÁ”s", 
psutž_´oc_io_couÁ”s
, 
METH_VARARGS
,

3061 {"´oc_is_su¥’ded", 
psutž_´oc_is_su¥’ded
, 
METH_VARARGS
,

3063 {"´oc_num_hªdËs", 
psutž_´oc_num_hªdËs
, 
METH_VARARGS
,

3065 {"´oc_num_ùx_sw™ches", 
psutž_´oc_num_ùx_sw™ches
, 
METH_VARARGS
,

3067 {"´oc_memÜy_m­s", 
psutž_´oc_memÜy_m­s
, 
METH_VARARGS
,

3071 {"´oc_ýu_times_2", 
psutž_´oc_ýu_times_2
, 
METH_VARARGS
,

3073 {"´oc_ü—‹_time_2", 
psutž_´oc_ü—‹_time_2
, 
METH_VARARGS
,

3075 {"´oc_num_hªdËs_2", 
psutž_´oc_num_hªdËs_2
, 
METH_VARARGS
,

3077 {"´oc_io_couÁ”s_2", 
psutž_´oc_io_couÁ”s_2
, 
METH_VARARGS
,

3079 {"´oc_memÜy_šfo_2", 
psutž_´oc_memÜy_šfo_2
, 
METH_VARARGS
,

3083 {"pids", 
psutž_pids
, 
METH_VARARGS
,

3085 {"µid_m­", 
psutž_µid_m­
, 
METH_VARARGS
,

3087 {"pid_exi¡s", 
psutž_pid_exi¡s
, 
METH_VARARGS
,

3089 {"ýu_couÁ_logiÿl", 
psutž_ýu_couÁ_logiÿl
, 
METH_VARARGS
,

3091 {"ýu_couÁ_phys", 
psutž_ýu_couÁ_phys
, 
METH_VARARGS
,

3093 {"boÙ_time", 
psutž_boÙ_time
, 
METH_VARARGS
,

3095 {"vœtu®_mem", 
psutž_vœtu®_mem
, 
METH_VARARGS
,

3097 {"ýu_times", 
psutž_ýu_times
, 
METH_VARARGS
,

3099 {"³r_ýu_times", 
psutž_³r_ýu_times
, 
METH_VARARGS
,

3101 {"disk_u§ge", 
psutž_disk_u§ge
, 
METH_VARARGS
,

3103 {"Ãt_io_couÁ”s", 
psutž_Ãt_io_couÁ”s
, 
METH_VARARGS
,

3105 {"disk_io_couÁ”s", 
psutž_disk_io_couÁ”s
, 
METH_VARARGS
,

3107 {"u£rs", 
psutž_u£rs
, 
METH_VARARGS
,

3109 {"disk_·¹™iÚs", 
psutž_disk_·¹™iÚs
, 
METH_VARARGS
,

3111 {"Ãt_cÚÃùiÚs", 
psutž_Ãt_cÚÃùiÚs
, 
METH_VARARGS
,

3116 {"wš32_Qu”yDosDeviû", 
psutž_wš32_Qu”yDosDeviû
, 
METH_VARARGS
,

3119 {
NULL
, NULL, 0, NULL}

3123 
	smoduË_¡©e
 {

3124 
PyObjeù
 *
	m”rÜ
;

3127 #ià
PY_MAJOR_VERSION
 >= 3

3128 

	#GETSTATE
(
m
è((
moduË_¡©e
*)
	`PyModuË_G‘S‹
(m))

	)

3130 

	#GETSTATE
(
m
è(&
_¡©e
)

	)

3131 
moduË_¡©e
 
	g_¡©e
;

3134 #ià
PY_MAJOR_VERSION
 >= 3

3136 
	$psutž_wšdows_Œav”£
(
PyObjeù
 *
m
, 
vis™´oc
 
vis™
, *
¬g
) {

3137 
	`Py_VISIT
(
	`GETSTATE
(
m
)->
”rÜ
);

3139 
	}
}

3141 
	$psutž_wšdows_þ—r
(
PyObjeù
 *
m
) {

3142 
	`Py_CLEAR
(
	`GETSTATE
(
m
)->
”rÜ
);

3144 
	}
}

3146 
PyModuËDef
 
	gmoduËdef
 = {

3147 
PyModuËDef_HEAD_INIT
,

3149 
NULL
,

3150 (
moduË_¡©e
),

3151 
PsutžM‘hods
,

3152 
NULL
,

3153 
psutž_wšdows_Œav”£
,

3154 
psutž_wšdows_þ—r
,

3155 
NULL


3158 

	#INITERROR
  
NULL


	)

3160 
PyMODINIT_FUNC
 
	$PyIn™__psutž_wšdows
()

3163 

	#INITERROR
 

	)

3164 
	$š™_psutž_wšdows
()

3167 
moduË_¡©e
 *
¡
 = 
NULL
;

3168 #ià
PY_MAJOR_VERSION
 >= 3

3169 
PyObjeù
 *
moduË
 = 
	`PyModuË_C»©e
(&
moduËdef
);

3171 
PyObjeù
 *
moduË
 = 
	`Py_In™ModuË
("_psutž_wšdows", 
PsutžM‘hods
);

3174 ià(
moduË
 =ð
NULL
) {

3175 
INITERROR
;

3178 
¡
 = 
	`GETSTATE
(
moduË
);

3179 
¡
->
”rÜ
 = 
	`PyE¼_NewExû±iÚ
("_psutž_wšdows.E¼Ü", 
NULL
, NULL);

3180 ià(
¡
->
”rÜ
 =ð
NULL
) {

3181 
	`Py_DECREF
(
moduË
);

3182 
INITERROR
;

3187 
	`PyModuË_AddIÁCÚ¡ªt
(

3188 
moduË
, "ABOVE_NORMAL_PRIORITY_CLASS", 
ABOVE_NORMAL_PRIORITY_CLASS
);

3189 
	`PyModuË_AddIÁCÚ¡ªt
(

3190 
moduË
, "BELOW_NORMAL_PRIORITY_CLASS", 
BELOW_NORMAL_PRIORITY_CLASS
);

3191 
	`PyModuË_AddIÁCÚ¡ªt
(

3192 
moduË
, "HIGH_PRIORITY_CLASS", 
HIGH_PRIORITY_CLASS
);

3193 
	`PyModuË_AddIÁCÚ¡ªt
(

3194 
moduË
, "IDLE_PRIORITY_CLASS", 
IDLE_PRIORITY_CLASS
);

3195 
	`PyModuË_AddIÁCÚ¡ªt
(

3196 
moduË
, "NORMAL_PRIORITY_CLASS", 
NORMAL_PRIORITY_CLASS
);

3197 
	`PyModuË_AddIÁCÚ¡ªt
(

3198 
moduË
, "REALTIME_PRIORITY_CLASS", 
REALTIME_PRIORITY_CLASS
);

3201 
	`PyModuË_AddIÁCÚ¡ªt
(

3202 
moduË
, "MIB_TCP_STATE_CLOSED", 
MIB_TCP_STATE_CLOSED
);

3203 
	`PyModuË_AddIÁCÚ¡ªt
(

3204 
moduË
, "MIB_TCP_STATE_CLOSING", 
MIB_TCP_STATE_CLOSING
);

3205 
	`PyModuË_AddIÁCÚ¡ªt
(

3206 
moduË
, "MIB_TCP_STATE_CLOSE_WAIT", 
MIB_TCP_STATE_CLOSE_WAIT
);

3207 
	`PyModuË_AddIÁCÚ¡ªt
(

3208 
moduË
, "MIB_TCP_STATE_LISTEN", 
MIB_TCP_STATE_LISTEN
);

3209 
	`PyModuË_AddIÁCÚ¡ªt
(

3210 
moduË
, "MIB_TCP_STATE_ESTAB", 
MIB_TCP_STATE_ESTAB
);

3211 
	`PyModuË_AddIÁCÚ¡ªt
(

3212 
moduË
, "MIB_TCP_STATE_SYN_SENT", 
MIB_TCP_STATE_SYN_SENT
);

3213 
	`PyModuË_AddIÁCÚ¡ªt
(

3214 
moduË
, "MIB_TCP_STATE_SYN_RCVD", 
MIB_TCP_STATE_SYN_RCVD
);

3215 
	`PyModuË_AddIÁCÚ¡ªt
(

3216 
moduË
, "MIB_TCP_STATE_FIN_WAIT1", 
MIB_TCP_STATE_FIN_WAIT1
);

3217 
	`PyModuË_AddIÁCÚ¡ªt
(

3218 
moduË
, "MIB_TCP_STATE_FIN_WAIT2", 
MIB_TCP_STATE_FIN_WAIT2
);

3219 
	`PyModuË_AddIÁCÚ¡ªt
(

3220 
moduË
, "MIB_TCP_STATE_LAST_ACK", 
MIB_TCP_STATE_LAST_ACK
);

3221 
	`PyModuË_AddIÁCÚ¡ªt
(

3222 
moduË
, "MIB_TCP_STATE_TIME_WAIT", 
MIB_TCP_STATE_TIME_WAIT
);

3223 
	`PyModuË_AddIÁCÚ¡ªt
(

3224 
moduË
, "MIB_TCP_STATE_TIME_WAIT", 
MIB_TCP_STATE_TIME_WAIT
);

3225 
	`PyModuË_AddIÁCÚ¡ªt
(

3226 
moduË
, "MIB_TCP_STATE_DELETE_TCB", 
MIB_TCP_STATE_DELETE_TCB
);

3227 
	`PyModuË_AddIÁCÚ¡ªt
(

3228 
moduË
, "PSUTIL_CONN_NONE", 
PSUTIL_CONN_NONE
);

3230 
	`PyModuË_AddIÁCÚ¡ªt
(

3231 
moduË
, "INFINITE", 
INFINITE
);

3232 
	`PyModuË_AddIÁCÚ¡ªt
(

3233 
moduË
, "ERROR_ACCESS_DENIED", 
ERROR_ACCESS_DENIED
);

3236 
	`psutž_£t_£_debug
();

3238 #ià
PY_MAJOR_VERSION
 >= 3

3239  
moduË
;

3241 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_windows.h

7 
	~<PythÚ.h
>

8 
	~<wšdows.h
>

12 
PyObjeù
* 
psutž_´oc_cmdlše
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

13 
PyObjeù
* 
psutž_´oc_ýu_affš™y_g‘
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

14 
PyObjeù
* 
psutž_´oc_ýu_affš™y_£t
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

15 
PyObjeù
* 
psutž_´oc_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

16 
PyObjeù
* 
psutž_´oc_ýu_times_2
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

17 
PyObjeù
* 
psutž_´oc_ü—‹_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

18 
PyObjeù
* 
psutž_´oc_ü—‹_time_2
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

19 
PyObjeù
* 
psutž_´oc_cwd
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

20 
PyObjeù
* 
psutž_´oc_exe
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

21 
PyObjeù
* 
psutž_´oc_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

22 
PyObjeù
* 
psutž_´oc_io_couÁ”s_2
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

23 
PyObjeù
* 
psutž_´oc_is_su¥’ded
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

24 
PyObjeù
* 
psutž_´oc_kžl
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

25 
PyObjeù
* 
psutž_´oc_memÜy_šfo
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

26 
PyObjeù
* 
psutž_´oc_memÜy_šfo_2
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

27 
PyObjeù
* 
psutž_´oc_memÜy_m­s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

28 
PyObjeù
* 
psutž_´oc_num_ùx_sw™ches
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

29 
PyObjeù
* 
psutž_´oc_num_hªdËs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

30 
PyObjeù
* 
psutž_´oc_num_hªdËs_2
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

31 
PyObjeù
* 
psutž_´oc_num_th»ads
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

32 
PyObjeù
* 
psutž_´oc_Ý’_fžes
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

33 
PyObjeù
* 
psutž_´oc_´iÜ™y_g‘
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

34 
PyObjeù
* 
psutž_´oc_´iÜ™y_£t
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

35 
PyObjeù
* 
psutž_´oc_»sume
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

36 
PyObjeù
* 
psutž_´oc_su¥’d
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

37 
PyObjeù
* 
psutž_´oc_th»ads
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

38 
PyObjeù
* 
psutž_´oc_u£ºame
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

39 
PyObjeù
* 
psutž_´oc_wa™
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

41 #ià(
PSUTIL_WINVER
 >= 0x0600)

42 
PyObjeù
* 
psutž_´oc_io_´iÜ™y_g‘
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

43 
PyObjeù
* 
psutž_´oc_io_´iÜ™y_£t
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

48 
PyObjeù
* 
psutž_boÙ_time
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

49 
PyObjeù
* 
psutž_ýu_couÁ_logiÿl
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

50 
PyObjeù
* 
psutž_ýu_couÁ_phys
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

51 
PyObjeù
* 
psutž_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

52 
PyObjeù
* 
psutž_disk_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

53 
PyObjeù
* 
psutž_disk_·¹™iÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

54 
PyObjeù
* 
psutž_disk_u§ge
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

55 
PyObjeù
* 
psutž_Ãt_cÚÃùiÚs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

56 
PyObjeù
* 
psutž_Ãt_io_couÁ”s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

57 
PyObjeù
* 
psutž_³r_ýu_times
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

58 
PyObjeù
* 
psutž_pid_exi¡s
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

59 
PyObjeù
* 
psutž_pids
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

60 
PyObjeù
* 
psutž_µid_m­
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

61 
PyObjeù
* 
psutž_u£rs
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

62 
PyObjeù
* 
psutž_vœtu®_mem
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

66 
PyObjeù
* 
psutž_wš32_Qu”yDosDeviû
(PyObjeù* 
£lf
, PyObjeù* 
¬gs
);

70 
psutž_´oc_su¥’d_Ü_»sume
(
DWORD
 
pid
, 
su¥’d
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\bsd\process_info.c

11 
	~<PythÚ.h
>

12 
	~<as£¹.h
>

13 
	~<Ӽo.h
>

14 
	~<¡dlib.h
>

15 
	~<¡dio.h
>

16 
	~<¡ršg.h
>

17 
	~<sys/ty³s.h
>

18 
	~<sys/sysùl.h
>

19 
	~<sys/·¿m.h
>

20 
	~<sys/u£r.h
>

21 
	~<sys/´oc.h
>

22 
	~<sigÇl.h
>

24 
	~"´oûss_šfo.h
"

36 
	$psutž_g‘_´oc_li¡
(
kšfo_´oc
 **
´ocLi¡
, 
size_t
 *
´ocCouÁ
)

38 
”r
;

39 
kšfo_´oc
 *
»suÉ
;

40 
dÚe
;

41 cÚ¡ 
Çme
[] = { 
CTL_KERN
, 
KERN_PROC
, 
KERN_PROC_PROC
, 0 };

44 
size_t
 
Ëngth
;

46 
	`as£¹
Ð
´ocLi¡
 !ð
NULL
);

47 
	`as£¹
(*
´ocLi¡
 =ð
NULL
);

48 
	`as£¹
(
´ocCouÁ
 !ð
NULL
);

50 *
´ocCouÁ
 = 0;

63 
»suÉ
 = 
NULL
;

64 
dÚe
 = 0;

66 
	`as£¹
(
»suÉ
 =ð
NULL
);

68 
Ëngth
 = 0;

69 
”r
 = 
	`sysùl
((*)
Çme
, ((name) / (*name)) - 1,

70 
NULL
, &
Ëngth
, NULL, 0);

71 ià(
”r
 == -1)

72 
”r
 = 
Ӽo
;

76 ià(
”r
 == 0) {

77 
»suÉ
 = 
	`m®loc
(
Ëngth
);

78 ià(
»suÉ
 =ð
NULL
)

79 
”r
 = 
ENOMEM
;

84 ià(
”r
 == 0) {

85 
”r
 = 
	`sysùl
((*è
Çme
, ((name) / (*name)) - 1,

86 
»suÉ
, &
Ëngth
, 
NULL
, 0);

87 ià(
”r
 == -1)

88 
”r
 = 
Ӽo
;

89 ià(
”r
 == 0) {

90 
dÚe
 = 1;

92 ià(
”r
 =ð
ENOMEM
) {

93 
	`as£¹
(
»suÉ
 !ð
NULL
);

94 
	`ä“
(
»suÉ
);

95 
»suÉ
 = 
NULL
;

96 
”r
 = 0;

99 } 
”r
 =ð0 && ! 
dÚe
);

102 ià(
”r
 !ð0 && 
»suÉ
 !ð
NULL
) {

103 
	`ä“
(
»suÉ
);

104 
»suÉ
 = 
NULL
;

107 *
´ocLi¡
 = 
»suÉ
;

108 *
´ocCouÁ
 = 
Ëngth
 / (
kšfo_´oc
);

110 
	`as£¹
((
”r
 =ð0è=ð(*
´ocLi¡
 !ð
NULL
));

111  
”r
;

112 
	}
}

116 *
	$psutž_g‘_cmd_·th
(
pid
, 
size_t
 *
·thsize
)

118 
mib
[4];

119 *
·th
;

120 
size_t
 
size
 = 0;

125 
mib
[0] = 
CTL_KERN
;

126 
mib
[1] = 
KERN_PROC
;

127 
mib
[2] = 
KERN_PROC_PATHNAME
;

128 
mib
[3] = 
pid
;

131 ià(
	`sysùl
(
mib
, 4, 
NULL
, &
size
, NULL, 0) == -1) {

132  
NULL
;

135 
·th
 = 
	`m®loc
(
size
);

136 ià(
·th
 =ð
NULL
) {

137 
	`PyE¼_NoMemÜy
();

138  
NULL
;

141 *
·thsize
 = 
size
;

142 ià(
	`sysùl
(
mib
, 4, 
·th
, &
size
, 
NULL
, 0) == -1) {

143 
	`ä“
(
·th
);

144  
NULL
;

147  
·th
;

148 
	}
}

165 *
	$psutž_g‘_cmd_¬gs
(
pid
, 
size_t
 *
¬gsize
)

167 
mib
[4], 
¬gmax
;

168 
size_t
 
size
 = (
¬gmax
);

169 *
´oÿrgs
 = 
NULL
;

172 
mib
[0] = 
CTL_KERN
;

173 
mib
[1] = 
KERN_ARGMAX
;

175 
size
 = (
¬gmax
);

176 ià(
	`sysùl
(
mib
, 2, &
¬gmax
, &
size
, 
NULL
, 0) == -1)

177  
NULL
;

180 
´oÿrgs
 = (*)
	`m®loc
(
¬gmax
);

181 ià(
´oÿrgs
 =ð
NULL
) {

182 
	`PyE¼_NoMemÜy
();

183  
NULL
;

189 
mib
[0] = 
CTL_KERN
;

190 
mib
[1] = 
KERN_PROC
;

191 
mib
[2] = 
KERN_PROC_ARGS
;

192 
mib
[3] = 
pid
;

194 
size
 = 
¬gmax
;

195 ià(
	`sysùl
(
mib
, 4, 
´oÿrgs
, &
size
, 
NULL
, 0) == -1) {

196 
	`ä“
(
´oÿrgs
);

197  
NULL
;

201 *
¬gsize
 = 
size
;

202  
´oÿrgs
;

203 
	}
}

207 
PyObjeù
 *

208 
	$psutž_g‘_¬g_li¡
(
pid
)

210 *
¬g¡r
 = 
NULL
;

211 
pos
 = 0;

212 
size_t
 
¬gsize
 = 0;

213 
PyObjeù
 *
»Ži¡
 = 
	`Py_BuždV®ue
("[]");

214 
PyObjeù
 *
™em
 = 
NULL
;

216 ià(
pid
 < 0) {

217  
»Ži¡
;

220 
¬g¡r
 = 
	`psutž_g‘_cmd_¬gs
(
pid
, &
¬gsize
);

221 ià(
¬g¡r
 =ð
NULL
) {

222 
”rÜ
;

228 ià(
¬gsize
 > 0) {

229 
pos
 < 
¬gsize
) {

230 
™em
 = 
	`Py_BuždV®ue
("s", &
¬g¡r
[
pos
]);

231 ià(!
™em
)

232 
”rÜ
;

233 ià(
	`PyLi¡_Aµ’d
(
»Ži¡
, 
™em
))

234 
”rÜ
;

235 
	`Py_DECREF
(
™em
);

236 
pos
 =…o + 
	`¡¾’
(&
¬g¡r
[pos]) + 1;

240 
	`ä“
(
¬g¡r
);

241  
»Ži¡
;

243 
”rÜ
:

244 
	`Py_XDECREF
(
™em
);

245 
	`Py_DECREF
(
»Ži¡
);

246 ià(
¬g¡r
 !ð
NULL
)

247 
	`ä“
(
¬g¡r
);

248  
NULL
;

249 
	}
}

256 
	$psutž_pid_exi¡s
(
pid
)

258 
kžl_»t
;

259 ià(
pid
 < 0) {

264 
kžl_»t
 = 
	`kžl
(
pid
 , 0);

265 ià((0 =ð
kžl_»t
è|| (
EPERM
 =ð
Ӽo
)) {

271 
	}
}

278 
	$psutž_¿i£_ad_Ü_n¥
(
pid
) {

279 ià(
	`psutž_pid_exi¡s
(
pid
) == 0) {

280 
	`NoSuchProûss
();

283 
	`AcûssD’›d
();

285 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\bsd\process_info.h

7 
	~<PythÚ.h
>

9 
kšfo_´oc
 
	tkšfo_´oc
;

11 *
psutž_g‘_cmd_¬gs
(
pid
, 
size_t
 *
¬gsize
);

12 *
psutž_g‘_cmd_·th
(
pid
, 
size_t
 *
·thsize
);

13 
psutž_g‘_´oc_li¡
(
kšfo_´oc
 **
´ocLi¡
, 
size_t
 *
´ocCouÁ
);

14 
psutž_pid_exi¡s
(
pid
);

15 
PyObjeù
* 
psutž_g‘_¬g_li¡
(
pid
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\osx\process_info.c

11 
	~<PythÚ.h
>

12 
	~<as£¹.h
>

13 
	~<Ӽo.h
>

14 
	~<lim™s.h
>

15 
	~<¡dboÞ.h
>

16 
	~<¡dlib.h
>

17 
	~<¡dio.h
>

18 
	~<sigÇl.h
>

19 
	~<sys/sysùl.h
>

20 
	~<lib´oc.h
>

22 
	~"´oûss_šfo.h
"

23 
	~"../../_psutž_commÚ.h
"

30 
	$psutž_pid_exi¡s
(
pid
)

32 
kžl_»t
;

35 ià(
pid
 < 0) {

40 
kžl_»t
 = 
	`kžl
(
pid
 , 0);

41 iàÐ(0 =ð
kžl_»t
è|| (
EPERM
 =ð
Ӽo
) ) {

47 
	}
}

59 
	$psutž_g‘_´oc_li¡
(
kšfo_´oc
 **
´ocLi¡
, 
size_t
 *
´ocCouÁ
)

63 cÚ¡ 
mib3
[3] = { 
CTL_KERN
, 
KERN_PROC
, 
KERN_PROC_ALL
 };

64 
size_t
 
size
, 
size2
;

65 *
±r
;

66 
”r
, 
lim
 = 8;

68 
	`as£¹
Ð
´ocLi¡
 !ð
NULL
);

69 
	`as£¹
(*
´ocLi¡
 =ð
NULL
);

70 
	`as£¹
(
´ocCouÁ
 !ð
NULL
);

72 *
´ocCouÁ
 = 0;

86 
lim
-- > 0) {

87 
size
 = 0;

88 ià(
	`sysùl
((*)
mib3
, 3, 
NULL
, &
size
, NULL, 0) == -1) {

89  
Ӽo
;

92 
size2
 = 
size
 + (size >> 3);

93 ià(
size2
 > 
size
) {

94 
±r
 = 
	`m®loc
(
size2
);

95 ià(
±r
 =ð
NULL
) {

96 
±r
 = 
	`m®loc
(
size
);

98 
size
 = 
size2
;

102 
±r
 = 
	`m®loc
(
size
);

104 ià(
±r
 =ð
NULL
) {

105  
ENOMEM
;

108 ià(
	`sysùl
((*)
mib3
, 3, 
±r
, &
size
, 
NULL
, 0) == -1) {

109 
”r
 = 
Ӽo
;

110 
	`ä“
(
±r
);

111 ià(
”r
 !ð
ENOMEM
) {

112  
”r
;

116 *
´ocLi¡
 = (
kšfo_´oc
 *)
±r
;

117 *
´ocCouÁ
 = 
size
 / (
kšfo_´oc
);

121  
ENOMEM
;

122 
	}
}

127 
	$psutž_g‘_¬gmax
()

129 
¬gmax
;

130 
mib
[] = { 
CTL_KERN
, 
KERN_ARGMAX
 };

131 
size_t
 
size
 = (
¬gmax
);

133 ià(
	`sysùl
(
mib
, 2, &
¬gmax
, &
size
, 
NULL
, 0) == 0) {

134  
¬gmax
;

137 
	}
}

141 
PyObjeù
 *

142 
	$psutž_g‘_¬g_li¡
(
pid
)

144 
mib
[3];

145 
Çrgs
;

146 
Ën
;

147 *
´oÿrgs
 = 
NULL
;

148 *
¬g_±r
;

149 *
¬g_’d
;

150 *
cu¼_¬g
;

151 
size_t
 
¬gmax
;

152 
PyObjeù
 *
¬g
 = 
NULL
;

153 
PyObjeù
 *
¬gli¡
 = 
NULL
;

156 ià(
pid
 == 0) {

157  
	`Py_BuždV®ue
("[]");

161 
¬gmax
 = 
	`psutž_g‘_¬gmax
();

162 ià(! 
¬gmax
) {

163 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

164 
”rÜ
;

167 
´oÿrgs
 = (*)
	`m®loc
(
¬gmax
);

168 ià(
NULL
 =ð
´oÿrgs
) {

169 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

170 
”rÜ
;

174 
mib
[0] = 
CTL_KERN
;

175 
mib
[1] = 
KERN_PROCARGS2
;

176 
mib
[2] = 
pid
;

177 ià(
	`sysùl
(
mib
, 3, 
´oÿrgs
, &
¬gmax
, 
NULL
, 0) < 0) {

178 ià(
EINVAL
 =ð
Ӽo
) {

180 iàÐ
	`psutž_pid_exi¡s
(
pid
) ) {

181 
	`AcûssD’›d
();

183 
	`NoSuchProûss
();

186 
”rÜ
;

189 
¬g_’d
 = &
´oÿrgs
[
¬gmax
];

191 
	`memýy
(&
Çrgs
, 
´oÿrgs
, (nargs));

193 
¬g_±r
 = 
´oÿrgs
 + (
Çrgs
);

194 
Ën
 = 
	`¡¾’
(
¬g_±r
);

195 
¬g_±r
 +ð
Ën
 + 1;

197 ià(
¬g_±r
 =ð
¬g_’d
) {

198 
	`ä“
(
´oÿrgs
);

199  
	`Py_BuždV®ue
("[]");

203 ; 
¬g_±r
 < 
¬g_’d
;‡rg_ptr++) {

204 ià(*
¬g_±r
 != '\0') {

210 
cu¼_¬g
 = 
¬g_±r
;

211 
¬gli¡
 = 
	`Py_BuždV®ue
("[]");

212 ià(!
¬gli¡
)

213 
”rÜ
;

214 
¬g_±r
 < 
¬g_’d
 && 
Çrgs
 > 0) {

215 ià(*
¬g_±r
++ == '\0') {

216 
¬g
 = 
	`Py_BuždV®ue
("s", 
cu¼_¬g
);

217 ià(!
¬g
)

218 
”rÜ
;

219 ià(
	`PyLi¡_Aµ’d
(
¬gli¡
, 
¬g
))

220 
”rÜ
;

221 
	`Py_DECREF
(
¬g
);

223 
cu¼_¬g
 = 
¬g_±r
;

224 
Çrgs
--;

228 
	`ä“
(
´oÿrgs
);

229  
¬gli¡
;

231 
”rÜ
:

232 
	`Py_XDECREF
(
¬g
);

233 
	`Py_XDECREF
(
¬gli¡
);

234 ià(
´oÿrgs
 !ð
NULL
)

235 
	`ä“
(
´oÿrgs
);

236  
NULL
;

237 
	}
}

241 
	$psutž_g‘_kšfo_´oc
(
pid_t
 
pid
, 
kšfo_´oc
 *
kp
)

243 
mib
[4];

244 
size_t
 
Ën
;

245 
mib
[0] = 
CTL_KERN
;

246 
mib
[1] = 
KERN_PROC
;

247 
mib
[2] = 
KERN_PROC_PID
;

248 
mib
[3] = 
pid
;

251 
Ën
 = (
kšfo_´oc
);

254 ià(
	`sysùl
(
mib
, 4, 
kp
, &
Ën
, 
NULL
, 0) == -1) {

256 
	`PyE¼_S‘FromE¼no
(
PyExc_OSE¼Ü
);

261 ià(
Ën
 == 0) {

262 
	`NoSuchProûss
();

266 
	}
}

273 
	$psutž_´oc_pidšfo
(
pid
, 
æavÜ
, *
±i
, 
size
)

275 
»t
 = 
	`´oc_pidšfo
(()
pid
, 
æavÜ
, 0, 
±i
, 
size
);

276 ià(
»t
 == 0) {

277 ià(! 
	`psutž_pid_exi¡s
(
pid
)) {

278 
	`NoSuchProûss
();

282 
	`AcûssD’›d
();

286 ià(
»t
 !ð
size
) {

287 
	`AcûssD’›d
();

293 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\osx\process_info.h

7 
	~<PythÚ.h
>

9 
kšfo_´oc
 
	tkšfo_´oc
;

11 
psutž_g‘_¬gmax
();

12 
psutž_g‘_kšfo_´oc
(
pid_t
 
pid
, 
kšfo_´oc
 *
kp
);

13 
psutž_g‘_´oc_li¡
(
kšfo_´oc
 **
´ocLi¡
, 
size_t
 *
´ocCouÁ
);

14 
psutž_pid_exi¡s
(
pid
);

15 
psutž_´oc_pidšfo
(
pid
, 
æavÜ
, *
±i
, 
size
);

16 
PyObjeù
* 
psutž_g‘_¬g_li¡
(
pid
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\glpi.h

3 
	e_LOGICAL_PROCESSOR_RELATIONSHIP
 {

4 
	mR–©iÚProûssÜCÜe
,

5 
	mR–©iÚNumaNode
,

6 
	mR–©iÚCache
,

7 
	mR–©iÚProûssÜPackage
,

8 
	mR–©iÚGroup
,

9 
	mR–©iÚAÎ
=0xffff

10 } 
	tLOGICAL_PROCESSOR_RELATIONSHIP
;

12 
	e_PROCESSOR_CACHE_TYPE
 {

13 
	mCacheUnif›d
,
	mCacheIn¡ruùiÚ
,
	mCacheD©a
,
	mCacheT¿û


14 } 
	tPROCESSOR_CACHE_TYPE
;

16 
	s_CACHE_DESCRIPTOR
 {

17 
BYTE
 
	mLev–
;

18 
BYTE
 
	mAssocŸtiv™y
;

19 
WORD
 
	mLšeSize
;

20 
DWORD
 
	mSize
;

21 
PROCESSOR_CACHE_TYPE
 
	mTy³
;

22 } 
	tCACHE_DESCRIPTOR
,*
	tPCACHE_DESCRIPTOR
;

24 
	s_SYSTEM_LOGICAL_PROCESSOR_INFORMATION
 {

25 
ULONG_PTR
 
	mProûssÜMask
;

26 
LOGICAL_PROCESSOR_RELATIONSHIP
 
	mR–©iÚsh
;

29 
BYTE
 
	mFÏgs
;

30 } 
	mProûssÜCÜe
;

32 
DWORD
 
	mNodeNumb”
;

33 } 
	mNumaNode
;

34 
CACHE_DESCRIPTOR
 
	mCache
;

35 
ULONGLONG
 
	mRe£rved
[2];

37 } 
	tSYSTEM_LOGICAL_PROCESSOR_INFORMATION
,*
	tPSYSTEM_LOGICAL_PROCESSOR_INFORMATION
;

39 
WINBASEAPI
 
WINBOOL
 
WINAPI


40 
G‘LogiÿlProûssÜInfÜm©iÚ
(
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION
 
Bufãr
,

41 
PDWORD
 
R‘uºedL’gth
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\ntextapi.h

7 
	e_KTHREAD_STATE
 {

8 
	mIn™Ÿlized
,

9 
	mR—dy
,

10 
	mRušg
,

11 
	mSndby
,

12 
	mT”mš©ed
,

13 
	mWa™šg
,

14 
	mT¿ns™iÚ
,

15 
	mDeã¼edR—dy
,

16 
	mG©eWa™
,

17 
	mMaximumTh»adS‹


18 } 
	tKTHREAD_STATE
, *
	tPKTHREAD_STATE
;

20 
	e_KWAIT_REASON
 {

21 
	mExecutive
 = 0,

22 
	mF»ePage
 = 1,

23 
	mPageIn
 = 2,

24 
	mPoÞAÎoÿtiÚ
 = 3,

25 
	mD–ayExecutiÚ
 = 4,

26 
	mSu¥’ded
 = 5,

27 
	mU£rReque¡
 = 6,

28 
	mWrExecutive
 = 7,

29 
	mWrF»ePage
 = 8,

30 
	mWrPageIn
 = 9,

31 
	mWrPoÞAÎoÿtiÚ
 = 10,

32 
	mWrD–ayExecutiÚ
 = 11,

33 
	mWrSu¥’ded
 = 12,

34 
	mWrU£rReque¡
 = 13,

35 
	mWrEv’tPaœ
 = 14,

36 
	mWrQueue
 = 15,

37 
	mWrLpcReûive
 = 16,

38 
	mWrLpcR•ly
 = 17,

39 
	mWrVœtu®MemÜy
 = 18,

40 
	mWrPageOut
 = 19,

41 
	mWrR’dezvous
 = 20,

42 
	mS·»2
 = 21,

43 
	mS·»3
 = 22,

44 
	mS·»4
 = 23,

45 
	mS·»5
 = 24,

46 
	mWrC®loutSck
 = 25,

47 
	mWrK”Ãl
 = 26,

48 
	mWrResourû
 = 27,

49 
	mWrPushLock
 = 28,

50 
	mWrMu‹x
 = 29,

51 
	mWrQuªtumEnd
 = 30,

52 
	mWrDi¥©chIÁ
 = 31,

53 
	mWrP»em±ed
 = 32,

54 
	mWrY›ldExecutiÚ
 = 33,

55 
	mWrFa¡Mu‹x
 = 34,

56 
	mWrGu¬dedMu‹x
 = 35,

57 
	mWrRundown
 = 36,

58 
	mMaximumWa™R—sÚ
 = 37

59 } 
	tKWAIT_REASON
, *
	tPKWAIT_REASON
;

61 
	s_CLIENT_ID
 {

62 
HANDLE
 
	mUniqueProûss
;

63 
HANDLE
 
	mUniqueTh»ad
;

64 } 
	tCLIENT_ID
, *
	tPCLIENT_ID
;

67 
	s_UNICODE_STRING
 {

68 
USHORT
 
	mL’gth
;

69 
USHORT
 
	mMaximumL’gth
;

70 
PWSTR
 
	mBufãr
;

71 } 
	tUNICODE_STRING
, *
	tPUNICODE_STRING
;

73 
	s_SYSTEM_TIMEOFDAY_INFORMATION
 {

74 
LARGE_INTEGER
 
	mBoÙTime
;

75 
LARGE_INTEGER
 
	mCu¼’tTime
;

76 
LARGE_INTEGER
 
	mTimeZÚeBŸs
;

77 
ULONG
 
	mTimeZÚeId
;

78 
ULONG
 
	mRe£rved
;

79 
ULONGLONG
 
	mBoÙTimeBŸs
;

80 
ULONGLONG
 
	mSË•TimeBŸs
;

81 } 
	tSYSTEM_TIMEOFDAY_INFORMATION
, *
	tPSYSTEM_TIMEOFDAY_INFORMATION
;

83 
	s_SYSTEM_THREAD_INFORMATION
 {

84 
LARGE_INTEGER
 
	mK”ÃlTime
;

85 
LARGE_INTEGER
 
	mU£rTime
;

86 
LARGE_INTEGER
 
	mC»©eTime
;

87 
ULONG
 
	mWa™Time
;

88 
PVOID
 
	mS¹Add»ss
;

89 
CLIENT_ID
 
	mCl›ÁId
;

90 
LONG
 
	mPriܙy
;

91 
LONG
 
	mBa£PriÜ™y
;

92 
ULONG
 
	mCÚ‹xtSw™ches
;

93 
ULONG
 
	mTh»adS‹
;

94 
KWAIT_REASON
 
	mWa™R—sÚ
;

95 } 
	tSYSTEM_THREAD_INFORMATION
, *
	tPSYSTEM_THREAD_INFORMATION
;

97 
_TEB
 *
	tPTEB
;

100 
	s_SYSTEM_EXTENDED_THREAD_INFORMATION
 {

101 
SYSTEM_THREAD_INFORMATION
 
	mTh»adInfo
;

102 
PVOID
 
	mSckBa£
;

103 
PVOID
 
	mSckLim™
;

104 
PVOID
 
	mWš32S¹Add»ss
;

105 
PTEB
 
	mTebBa£
;

106 
ULONG_PTR
 
	mRe£rved2
;

107 
ULONG_PTR
 
	mRe£rved3
;

108 
ULONG_PTR
 
	mRe£rved4
;

109 } 
	tSYSTEM_EXTENDED_THREAD_INFORMATION
, *
	tPSYSTEM_EXTENDED_THREAD_INFORMATION
;

111 
	s_SYSTEM_PROCESS_INFORMATION
 {

112 
ULONG
 
	mNextEÁryOff£t
;

113 
ULONG
 
	mNumb”OfTh»ads
;

114 
LARGE_INTEGER
 
	mS·»Li1
;

115 
LARGE_INTEGER
 
	mS·»Li2
;

116 
LARGE_INTEGER
 
	mS·»Li3
;

117 
LARGE_INTEGER
 
	mC»©eTime
;

118 
LARGE_INTEGER
 
	mU£rTime
;

119 
LARGE_INTEGER
 
	mK”ÃlTime
;

120 
UNICODE_STRING
 
	mImageName
;

121 
LONG
 
	mBa£PriÜ™y
;

122 
HANDLE
 
	mUniqueProûssId
;

123 
HANDLE
 
	mInh”™edFromUniqueProûssId
;

124 
ULONG
 
	mHªdËCouÁ
;

125 
ULONG
 
	mSessiÚId
;

126 
ULONG_PTR
 
	mPageDœeùÜyBa£
;

127 
SIZE_T
 
	mP—kVœtu®Size
;

128 
SIZE_T
 
	mVœtu®Size
;

129 
DWORD
 
	mPageFauÉCouÁ
;

130 
SIZE_T
 
	mP—kWÜkšgS‘Size
;

131 
SIZE_T
 
	mWÜkšgS‘Size
;

132 
SIZE_T
 
	mQuÙaP—kPagedPoÞU§ge
;

133 
SIZE_T
 
	mQuÙaPagedPoÞU§ge
;

134 
SIZE_T
 
	mQuÙaP—kNÚPagedPoÞU§ge
;

135 
SIZE_T
 
	mQuÙaNÚPagedPoÞU§ge
;

136 
SIZE_T
 
	mPagefžeU§ge
;

137 
SIZE_T
 
	mP—kPagefžeU§ge
;

138 
SIZE_T
 
	mPriv©ePageCouÁ
;

139 
LARGE_INTEGER
 
	mR—dO³¿tiÚCouÁ
;

140 
LARGE_INTEGER
 
	mWr™eO³¿tiÚCouÁ
;

141 
LARGE_INTEGER
 
	mOth”O³¿tiÚCouÁ
;

142 
LARGE_INTEGER
 
	mR—dT¿nsãrCouÁ
;

143 
LARGE_INTEGER
 
	mWr™eT¿nsãrCouÁ
;

144 
LARGE_INTEGER
 
	mOth”T¿nsãrCouÁ
;

145 
SYSTEM_THREAD_INFORMATION
 
	mTh»ads
[1];

146 } 
	tSYSTEM_PROCESS_INFORMATION
, *
	tPSYSTEM_PROCESS_INFORMATION
;

150 
	s_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
 {

151 
LARGE_INTEGER
 
	mIdËTime
;

152 
LARGE_INTEGER
 
	mK”ÃlTime
;

153 
LARGE_INTEGER
 
	mU£rTime
;

154 
LARGE_INTEGER
 
	mRe£rved1
[2];

155 
ULONG
 
	mRe£rved2
;

156 } 
	tSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
,

157 *
	tPSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
;

160 
	e_SYSTEM_INFORMATION_CLASS
 {

161 
	mSy¡emBasicInfÜm©iÚ
 = 0,

162 
	mSy¡emP”fÜmªûInfÜm©iÚ
 = 2,

163 
	mSy¡emTimeOfDayInfÜm©iÚ
 = 3,

164 
	mSy¡emProûssInfÜm©iÚ
 = 5,

165 
	mSy¡emProûssÜP”fÜmªûInfÜm©iÚ
 = 8,

166 
	mSy¡emIÁ”ru±InfÜm©iÚ
 = 23,

167 
	mSy¡emExû±iÚInfÜm©iÚ
 = 33,

168 
	mSy¡emRegi¡ryQuÙaInfÜm©iÚ
 = 37,

169 
	mSy¡emLookasideInfÜm©iÚ
 = 45

170 } 
	tSYSTEM_INFORMATION_CLASS
;

177 
	s_WINSTATION_INFO
 {

178 
BYTE
 
	mRe£rved1
[72];

179 
ULONG
 
	mSessiÚId
;

180 
BYTE
 
	mRe£rved2
[4];

181 
FILETIME
 
	mCÚÃùTime
;

182 
FILETIME
 
	mDiscÚÃùTime
;

183 
FILETIME
 
	mLa¡IÅutTime
;

184 
FILETIME
 
	mLogšTime
;

185 
BYTE
 
	mRe£rved3
[1096];

186 
FILETIME
 
	mCu¼’tTime
;

187 } 
	tWINSTATION_INFO
, *
	tPWINSTATION_INFO
;

189 
	e_WINSTATIONINFOCLASS
 {

190 
	mWšStiÚInfÜm©iÚ
 = 8

191 } 
	tWINSTATIONINFOCLASS
;

193 
	$BOOLEAN
 (
	tWINAPI
 * 
	tPWINSTATIONQUERYINFORMATIONW
)

194 (
	tHANDLE
,
	tULONG
,
	tWINSTATIONINFOCLASS
,
	tPVOID
,ULONG,
	tPULONG
);

196 
	s_WINSTATIONINFORMATIONW
 {

197 
BYTE
 
Re£rved2
[70];

198 
ULONG
 
LogÚId
;

199 
BYTE
 
Re£rved3
[1140];

200 } 
	tWINSTATIONINFORMATIONW
, *
	tPWINSTATIONINFORMATIONW
;

204 #iâdeà
_INC_WTSAPI


205 
	s_WTS_CLIENT_ADDRESS
 {

206 
DWORD
 
Add»ssFamžy
;

207 
BYTE
 
Add»ss
[20];

208 } 
	tWTS_CLIENT_ADDRESS
, * 
	tPWTS_CLIENT_ADDRESS
;

210 
HANDLE
 
WINAPI
 
	`WTSO³nS”v”A
(
IN
 
LPSTR
 
pS”v”Name
);

212 
VOID
 
WINAPI
 
	`WTSClo£S”v”
(
IN
 
HANDLE
 
hS”v”
);

221 
LONG
 
	tNTSTATUS
;

223 
	$NTSTATUS
 (
	tNTAPI
 *
	t_NtQu”yInfÜm©iÚProûss
)(

224 
	tHANDLE
 
	tProûssHªdË
,

225 
	tDWORD
 
	tProûssInfÜm©iÚCÏss
,

226 
	tPVOID
 
	tProûssInfÜm©iÚ
,

227 
	tDWORD
 
	tProûssInfÜm©iÚL’gth
,

228 
	tPDWORD
 
	tR‘uºL’gth


231 
	$NTSTATUS
 (
	tNTAPI
 *
	t_NtS‘InfÜm©iÚProûss
)(

232 
	tHANDLE
 
	tProûssHªdË
,

233 
	tDWORD
 
	tProûssInfÜm©iÚCÏss
,

234 
	tPVOID
 
	tProûssInfÜm©iÚ
,

235 
	tDWORD
 
	tProûssInfÜm©iÚL’gth


238 
	s_PROCESS_BASIC_INFORMATION
 {

239 
PVOID
 
Re£rved1
;

240 
PVOID
 
PebBa£Add»ss
;

241 
PVOID
 
Re£rved2
[2];

242 
ULONG_PTR
 
UniqueProûssId
;

243 
PVOID
 
Re£rved3
;

244 } 
	tPROCESS_BASIC_INFORMATION
, *
	tPPROCESS_BASIC_INFORMATION
;

246 
	e_PROCESSINFOCLASS
 {

247 
ProûssBasicInfÜm©iÚ
,

248 
ProûssQuÙaLim™s
,

249 
ProûssIoCouÁ”s
,

250 
ProûssVmCouÁ”s
,

251 
ProûssTimes
,

252 
ProûssBa£PriÜ™y
,

253 
ProûssRai£PriÜ™y
,

254 
ProûssDebugPÜt
,

255 
ProûssExû±iÚPÜt
,

256 
ProûssAcûssTok’
,

257 
ProûssLdtInfÜm©iÚ
,

258 
ProûssLdtSize
,

259 
ProûssDeçuÉH¬dE¼ÜMode
,

260 
ProûssIoPÜtHªdËrs
,

261 
ProûssPoÞedU§geAndLim™s
,

262 
ProûssWÜkšgS‘W©ch
,

263 
ProûssU£rModeIOPL
,

264 
ProûssEÇbËAlignm’tFauÉFixup
,

265 
ProûssPriÜ™yCÏss
,

266 
ProûssWx86InfÜm©iÚ
,

267 
ProûssHªdËCouÁ
,

268 
ProûssAffš™yMask
,

269 
ProûssPriÜ™yBoo¡
,

270 
ProûssDeviûM­
,

271 
ProûssSessiÚInfÜm©iÚ
,

272 
ProûssFÜegroundInfÜm©iÚ
,

273 
ProûssWow64InfÜm©iÚ
,

275 
ProûssImageFžeName
,

276 
ProûssLUIDDeviûM­sEÇbËd
,

277 
ProûssB»akOnT”mš©iÚ
,

278 
ProûssDebugObjeùHªdË
,

279 
ProûssDebugFÏgs
,

280 
ProûssHªdËT¿cšg
,

281 
ProûssIoPriÜ™y
,

282 
ProûssExecu‹FÏgs
,

283 
ProûssResourûMªagem’t
,

284 
ProûssCook›
,

285 
ProûssImageInfÜm©iÚ
,

286 
MaxProûssInfoCÏss


287 } 
	tPROCESSINFOCLASS
;

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_handles.c

8 #iâdeà
UNICODE


9 

	#UNICODE


	)

12 
	~<PythÚ.h
>

13 
	~<wšdows.h
>

14 
	~<¡dio.h
>

15 
	~"´oûss_hªdËs.h
"

17 #iâdeà
NT_SUCCESS


18 

	#NT_SUCCESS
(
x
è((xè>ð0)

	)

20 

	#STATUS_INFO_LENGTH_MISMATCH
 0xc0000004

	)

22 

	#Sy¡emHªdËInfÜm©iÚ
 16

	)

23 

	#ObjeùBasicInfÜm©iÚ
 0

	)

24 

	#ObjeùNameInfÜm©iÚ
 1

	)

25 

	#ObjeùTy³InfÜm©iÚ
 2

	)

28 
LONG
 
	tNTSTATUS
;

30 
	s_UNICODE_STRING
 {

31 
USHORT
 
	mL’gth
;

32 
USHORT
 
	mMaximumL’gth
;

33 
PWSTR
 
	mBufãr
;

34 } 
	tUNICODE_STRING
, *
	tPUNICODE_STRING
;

36 
	$NTSTATUS
 (
	tNTAPI
 *
	t_NtQu”ySy¡emInfÜm©iÚ
)(

37 
	tULONG
 
	tSy¡emInfÜm©iÚCÏss
,

38 
	tPVOID
 
	tSy¡emInfÜm©iÚ
,

39 
	tULONG
 
	tSy¡emInfÜm©iÚL’gth
,

40 
	tPULONG
 
	tR‘uºL’gth


43 
	$NTSTATUS
 (
	tNTAPI
 *
	t_NtDu¶iÿ‹Objeù
)(

44 
	tHANDLE
 
	tSourûProûssHªdË
,

45 
	tHANDLE
 
	tSourûHªdË
,

46 
	tHANDLE
 
	tT¬g‘ProûssHªdË
,

47 
	tPHANDLE
 
	tT¬g‘HªdË
,

48 
	tACCESS_MASK
 
	tDesœedAcûss
,

49 
	tULONG
 
	tA‰ribu‹s
,

50 
	tULONG
 
	tO±iÚs


53 
	$NTSTATUS
 (
	tNTAPI
 *
	t_NtQu”yObjeù
)(

54 
	tHANDLE
 
	tObjeùHªdË
,

55 
	tULONG
 
	tObjeùInfÜm©iÚCÏss
,

56 
	tPVOID
 
	tObjeùInfÜm©iÚ
,

57 
	tULONG
 
	tObjeùInfÜm©iÚL’gth
,

58 
	tPULONG
 
	tR‘uºL’gth


61 
	s_SYSTEM_HANDLE
 {

62 
ULONG
 
ProûssId
;

63 
BYTE
 
ObjeùTy³Numb”
;

64 
BYTE
 
FÏgs
;

65 
USHORT
 
HªdË
;

66 
PVOID
 
Objeù
;

67 
ACCESS_MASK
 
G¿ÁedAcûss
;

68 } 
	tSYSTEM_HANDLE
, *
	tPSYSTEM_HANDLE
;

70 
	s_SYSTEM_HANDLE_INFORMATION
 {

71 
ULONG
 
HªdËCouÁ
;

72 
SYSTEM_HANDLE
 
HªdËs
[1];

73 } 
	tSYSTEM_HANDLE_INFORMATION
, *
	tPSYSTEM_HANDLE_INFORMATION
;

75 
	e_POOL_TYPE
 {

76 
NÚPagedPoÞ
,

77 
PagedPoÞ
,

78 
NÚPagedPoÞMu¡Sucûed
,

79 
DÚtU£ThisTy³
,

80 
NÚPagedPoÞCacheAligÃd
,

81 
PagedPoÞCacheAligÃd
,

82 
NÚPagedPoÞCacheAligÃdMu¡S


83 } 
	tPOOL_TYPE
, *
	tPPOOL_TYPE
;

85 
	s_OBJECT_TYPE_INFORMATION
 {

86 
UNICODE_STRING
 
Name
;

87 
ULONG
 
TÙ®Numb”OfObjeùs
;

88 
ULONG
 
TÙ®Numb”OfHªdËs
;

89 
ULONG
 
TÙ®PagedPoÞU§ge
;

90 
ULONG
 
TÙ®NÚPagedPoÞU§ge
;

91 
ULONG
 
TÙ®NamePoÞU§ge
;

92 
ULONG
 
TÙ®HªdËTabËU§ge
;

93 
ULONG
 
HighW©”Numb”OfObjeùs
;

94 
ULONG
 
HighW©”Numb”OfHªdËs
;

95 
ULONG
 
HighW©”PagedPoÞU§ge
;

96 
ULONG
 
HighW©”NÚPagedPoÞU§ge
;

97 
ULONG
 
HighW©”NamePoÞU§ge
;

98 
ULONG
 
HighW©”HªdËTabËU§ge
;

99 
ULONG
 
Inv®idA‰ribu‹s
;

100 
GENERIC_MAPPING
 
G’”icM­pšg
;

101 
ULONG
 
V®idAcûss
;

102 
BOOLEAN
 
Secur™yRequœed
;

103 
BOOLEAN
 
MaššHªdËCouÁ
;

104 
USHORT
 
MaššTy³Li¡
;

105 
POOL_TYPE
 
PoÞTy³
;

106 
ULONG
 
PagedPoÞU§ge
;

107 
ULONG
 
NÚPagedPoÞU§ge
;

108 } 
	tOBJECT_TYPE_INFORMATION
, *
	tPOBJECT_TYPE_INFORMATION
;

111 
PVOID


112 
	$G‘Lib¿ryProcAdd»ss
(
PSTR
 
Lib¿ryName
, PSTR 
ProcName
)

114  
	`G‘ProcAdd»ss
(
	`G‘ModuËHªdËA
(
Lib¿ryName
), 
ProcName
);

115 
	}
}

118 
PyObjeù
 *

119 
	$psutž_g‘_Ý’_fžes
(
pid
, 
HANDLE
 
´oûssHªdË
)

121 
_NtQu”ySy¡emInfÜm©iÚ
 
NtQu”ySy¡emInfÜm©iÚ
 =

122 
	`G‘Lib¿ryProcAdd»ss
("ntdll.dll", "NtQuerySystemInformation");

123 
_NtQu”yObjeù
 
NtQu”yObjeù
 =

124 
	`G‘Lib¿ryProcAdd»ss
("ntdll.dll", "NtQueryObject");

126 
NTSTATUS
 
¡©us
;

127 
PSYSTEM_HANDLE_INFORMATION
 
hªdËInfo
;

128 
ULONG
 
hªdËInfoSize
 = 0x10000;

129 
ULONG
 
i
;

130 
ULONG
 
fžeNameL’gth
;

131 
PyObjeù
 *
fžesLi¡
 = 
	`Py_BuždV®ue
("[]");

132 
PyObjeù
 *
¬g
 = 
NULL
;

133 
PyObjeù
 *
fžeFromWch¬
 = 
NULL
;

135 ià(
fžesLi¡
 =ð
NULL
)

136  
NULL
;

138 
hªdËInfo
 = (
PSYSTEM_HANDLE_INFORMATION
)
	`m®loc
(
hªdËInfoSize
);

139 ià(
hªdËInfo
 =ð
NULL
) {

140 
	`Py_DECREF
(
fžesLi¡
);

141 
	`PyE¼_NoMemÜy
();

142  
NULL
;

147 (
¡©us
 = 
	`NtQu”ySy¡emInfÜm©iÚ
(

148 
Sy¡emHªdËInfÜm©iÚ
,

149 
hªdËInfo
,

150 
hªdËInfoSize
,

151 
NULL


152 )è=ð
STATUS_INFO_LENGTH_MISMATCH
)

154 
hªdËInfo
 = (
PSYSTEM_HANDLE_INFORMATION
) \

155 
	`»®loc
(
hªdËInfo
, 
hªdËInfoSize
 *= 2);

159 ià(!
	`NT_SUCCESS
(
¡©us
)) {

160 
	`Py_DECREF
(
fžesLi¡
);

161 
	`ä“
(
hªdËInfo
);

162  
NULL
;

165 
i
 = 0; i < 
hªdËInfo
->
HªdËCouÁ
; i++) {

166 
SYSTEM_HANDLE
 
hªdË
 = 
hªdËInfo
->
HªdËs
[
i
];

167 
HANDLE
 
dupHªdË
 = 
NULL
;

168 
HANDLE
 
m­HªdË
 = 
NULL
;

169 
POBJECT_TYPE_INFORMATION
 
objeùTy³Info
 = 
NULL
;

170 
PVOID
 
objeùNameInfo
;

171 
UNICODE_STRING
 
objeùName
;

172 
ULONG
 
»tuºL’gth
;

173 
DWORD
 
”rÜ
 = 0;

174 
fžeFromWch¬
 = 
NULL
;

175 
¬g
 = 
NULL
;

178 ià(
hªdË
.
ProûssId
 !ð
pid
)

183 ià((
hªdË
.
G¿ÁedAcûss
 == 0x0012019f)

184 || (
hªdË
.
G¿ÁedAcûss
 == 0x001a019f)

185 || (
hªdË
.
G¿ÁedAcûss
 == 0x00120189)

186 || (
hªdË
.
G¿ÁedAcûss
 == 0x00100000)) {

190 ià(!
	`Du¶iÿ‹HªdË
(
´oûssHªdË
,

191 
hªdË
.
HªdË
,

192 
	`G‘Cu¼’tProûss
(),

193 &
dupHªdË
,

195 
TRUE
,

196 
DUPLICATE_SAME_ACCESS
))

203 
m­HªdË
 = 
	`C»©eFžeM­pšg
(
dupHªdË
,

204 
NULL
,

205 
PAGE_READONLY
,

208 
NULL
);

209 ià(
m­HªdË
 =ð
NULL
 &&

210 (
”rÜ
 =ð
ERROR_INVALID_HANDLE
 ||

211 
”rÜ
 =ð
ERROR_BAD_EXE_FORMAT
)) {

212 
	`Clo£HªdË
(
dupHªdË
);

216 
	`Clo£HªdË
(
m­HªdË
);

219 
objeùTy³Info
 = (
POBJECT_TYPE_INFORMATION
)
	`m®loc
(0x1000);

220 ià(!
	`NT_SUCCESS
(
	`NtQu”yObjeù
(

221 
dupHªdË
,

222 
ObjeùTy³InfÜm©iÚ
,

223 
objeùTy³Info
,

225 
NULL


228 
	`ä“
(
objeùTy³Info
);

229 
	`Clo£HªdË
(
dupHªdË
);

233 
objeùNameInfo
 = 
	`m®loc
(0x1000);

234 ià(!
	`NT_SUCCESS
(
	`NtQu”yObjeù
(

235 
dupHªdË
,

236 
ObjeùNameInfÜm©iÚ
,

237 
objeùNameInfo
,

239 &
»tuºL’gth


243 
objeùNameInfo
 = 
	`»®loc
(objeùNameInfo, 
»tuºL’gth
);

244 ià(!
	`NT_SUCCESS
(
	`NtQu”yObjeù
(

245 
dupHªdË
,

246 
ObjeùNameInfÜm©iÚ
,

247 
objeùNameInfo
,

248 
»tuºL’gth
,

249 
NULL


261 
	`ä“
(
objeùTy³Info
);

262 
	`ä“
(
objeùNameInfo
);

263 
	`Clo£HªdË
(
dupHªdË
);

270 
objeùName
 = *(
PUNICODE_STRING
)
objeùNameInfo
;

273 ià(
objeùName
.
L’gth
)

277 
fžeNameL’gth
 = 
objeùName
.
L’gth
 / 2;

278 ià(
	`wcscmp
(
objeùTy³Info
->
Name
.
Bufãr
, 
L
"File") == 0) {

280 
fžeFromWch¬
 = 
	`PyUnicode_FromWideCh¬
(
objeùName
.
Bufãr
,

281 
fžeNameL’gth
);

282 ià(
fžeFromWch¬
 =ð
NULL
)

283 
”rÜ_py_fun
;

284 #ià
PY_MAJOR_VERSION
 >= 3

285 
¬g
 = 
	`Py_BuždV®ue
("N",

286 
	`PyUnicode_AsUTF8SŒšg
(
fžeFromWch¬
));

288 
¬g
 = 
	`Py_BuždV®ue
("N",

289 
	`PyUnicode_FromObjeù
(
fžeFromWch¬
));

291 ià(!
¬g
)

292 
”rÜ_py_fun
;

293 
	`Py_XDECREF
(
fžeFromWch¬
);

294 
fžeFromWch¬
 = 
NULL
;

295 ià(
	`PyLi¡_Aµ’d
(
fžesLi¡
, 
¬g
))

296 
”rÜ_py_fun
;

297 
	`Py_XDECREF
(
¬g
);

323 
	`ä“
(
objeùTy³Info
);

324 
	`ä“
(
objeùNameInfo
);

325 
	`Clo£HªdË
(
dupHªdË
);

327 
	`ä“
(
hªdËInfo
);

328 
	`Clo£HªdË
(
´oûssHªdË
);

329  
fžesLi¡
;

331 
”rÜ_py_fun
:

332 
	`Py_XDECREF
(
¬g
);

333 
	`Py_XDECREF
(
fžeFromWch¬
);

334 
	`Py_DECREF
(
fžesLi¡
);

335  
NULL
;

336 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_handles.h

7 
	~<PythÚ.h
>

8 
	~<wšdows.h
>

10 
PyObjeù
* 
psutž_g‘_Ý’_fžes
(
pid
, 
HANDLE
 
´oûssHªdË
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_info.c

10 
	~<PythÚ.h
>

11 
	~<wšdows.h
>

12 
	~<P§pi.h
>

13 
	~<Žh–p32.h
>

15 
	~"£cur™y.h
"

16 
	~"´oûss_šfo.h
"

17 
	~"Áexpi.h
"

18 
	~"../../_psutž_commÚ.h
"

28 
HANDLE


29 
	$psutž_hªdË_äom_pid_wacûss
(
DWORD
 
pid
, DWORD 
dwDesœedAcûss
)

31 
HANDLE
 
hProûss
;

32 
DWORD
 
´oûssEx™Code
 = 0;

34 ià(
pid
 == 0) {

36  
	`AcûssD’›d
();

39 
hProûss
 = 
	`O³nProûss
(
dwDesœedAcûss
, 
FALSE
, 
pid
);

40 ià(
hProûss
 =ð
NULL
) {

41 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_INVALID_PARAMETER
) {

42 
	`NoSuchProûss
();

45 
	`PyE¼_S‘FromWšdowsE¼
(0);

47  
NULL
;

51 
	`G‘Ex™CodeProûss
(
hProûss
, &
´oûssEx™Code
);

52 ià(
´oûssEx™Code
 == 0) {

53 
	`NoSuchProûss
();

54 
	`Clo£HªdË
(
hProûss
);

55  
NULL
;

57  
hProûss
;

58 
	}
}

66 
HANDLE


67 
	$psutž_hªdË_äom_pid
(
DWORD
 
pid
) {

68 
DWORD
 
dwDesœedAcûss
 = 
PROCESS_QUERY_INFORMATION
 | 
PROCESS_VM_READ
;

69  
	`psutž_hªdË_äom_pid_wacûss
(
pid
, 
dwDesœedAcûss
);

70 
	}
}

74 
PVOID


75 
	$psutž_g‘_³b_add»ss
(
HANDLE
 
ProûssHªdË
)

77 
_NtQu”yInfÜm©iÚProûss
 
NtQu”yInfÜm©iÚProûss
 =

78 (
_NtQu”yInfÜm©iÚProûss
)
	`G‘ProcAdd»ss
(

79 
	`G‘ModuËHªdËA
("ntdll.dll"), "NtQueryInformationProcess");

80 
PROCESS_BASIC_INFORMATION
 
pbi
;

82 
	`NtQu”yInfÜm©iÚProûss
(
ProûssHªdË
, 0, &
pbi
, Õbi), 
NULL
);

83  
pbi
.
PebBa£Add»ss
;

84 
	}
}

87 
DWORD
 *

88 
	$psutž_g‘_pids
(
DWORD
 *
numb”OfR‘uºedPIDs
) {

95 
DWORD
 *
´ocA¼ay
 = 
NULL
;

96 
DWORD
 
´ocA¼ayBy‹Sz
;

97 
´ocA¼aySz
 = 0;

100 
DWORD
 
’umR‘uºSz
 = 0;

103 
´ocA¼aySz
 += 1024;

104 
	`ä“
(
´ocA¼ay
);

105 
´ocA¼ayBy‹Sz
 = 
´ocA¼aySz
 * (
DWORD
);

106 
´ocA¼ay
 = 
	`m®loc
(
´ocA¼ayBy‹Sz
);

107 ià(
´ocA¼ay
 =ð
NULL
) {

108 
	`PyE¼_NoMemÜy
();

109  
NULL
;

111 ià(! 
	`EnumProûs£s
(
´ocA¼ay
, 
´ocA¼ayBy‹Sz
, &
’umR‘uºSz
)) {

112 
	`ä“
(
´ocA¼ay
);

113 
	`PyE¼_S‘FromWšdowsE¼
(0);

114  
NULL
;

116 } 
’umR‘uºSz
 =ð
´ocA¼aySz
 * (
DWORD
));

119 *
numb”OfR‘uºedPIDs
 = 
’umR‘uºSz
 / (
DWORD
);

121  
´ocA¼ay
;

122 
	}
}

126 
	$psutž_pid_is_rušg
(
DWORD
 
pid
)

128 
HANDLE
 
hProûss
;

129 
DWORD
 
ex™Code
;

132 ià(
pid
 == 0) {

136 ià(
pid
 < 0) {

140 
hProûss
 = 
	`O³nProûss
(
PROCESS_QUERY_INFORMATION
 | 
PROCESS_VM_READ
,

141 
FALSE
, 
pid
);

142 ià(
NULL
 =ð
hProûss
) {

144 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_INVALID_PARAMETER
) {

145 
	`Clo£HªdË
(
hProûss
);

150 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_ACCESS_DENIED
) {

151 
	`Clo£HªdË
(
hProûss
);

155 
	`Clo£HªdË
(
hProûss
);

156 
	`PyE¼_S‘FromWšdowsE¼
(0);

160 ià(
	`G‘Ex™CodeProûss
(
hProûss
, &
ex™Code
)) {

161 
	`Clo£HªdË
(
hProûss
);

162  (
ex™Code
 =ð
STILL_ACTIVE
);

167 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_ACCESS_DENIED
) {

168 
	`Clo£HªdË
(
hProûss
);

172 
	`PyE¼_S‘FromWšdowsE¼
(0);

173 
	`Clo£HªdË
(
hProûss
);

175 
	}
}

179 
	$psutž_pid_š_´oþi¡
(
DWORD
 
pid
)

181 
DWORD
 *
´oþi¡
 = 
NULL
;

182 
DWORD
 
numb”OfR‘uºedPIDs
;

183 
DWORD
 
i
;

185 
´oþi¡
 = 
	`psutž_g‘_pids
(&
numb”OfR‘uºedPIDs
);

186 ià(
NULL
 =ð
´oþi¡
) {

190 
i
 = 0; i < 
numb”OfR‘uºedPIDs
; i++) {

191 ià(
pid
 =ð
´oþi¡
[
i
]) {

192 
	`ä“
(
´oþi¡
);

197 
	`ä“
(
´oþi¡
);

199 
	}
}

205 
	$hªdËp_is_rušg
(
HANDLE
 
hProûss
)

207 
DWORD
 
dwCode
;

208 ià(
NULL
 =ð
hProûss
) {

211 ià(
	`G‘Ex™CodeProûss
(
hProûss
, &
dwCode
)) {

212 ià(
dwCode
 =ð
STILL_ACTIVE
) {

217 
	}
}

224 
PyObjeù
 *

225 
	$psutž_g‘_¬g_li¡
(
pid
)

227 
nArgs
, 
i
;

228 
LPWSTR
 *
szArgli¡
 = 
NULL
;

229 
HANDLE
 
hProûss
 = 
NULL
;

230 
PVOID
 
³bAdd»ss
;

231 
PVOID
 
¹lU£rProcP¬amsAdd»ss
;

232 
UNICODE_STRING
 
commªdLše
;

233 
WCHAR
 *
commªdLšeCÚ‹Ás
 = 
NULL
;

234 
PyObjeù
 *
¬g
 = 
NULL
;

235 
PyObjeù
 *
¬g_äom_wch¬
 = 
NULL
;

236 
PyObjeù
 *
¬gLi¡
 = 
NULL
;

238 
hProûss
 = 
	`psutž_hªdË_äom_pid
(
pid
);

239 ià(
hProûss
 =ð
NULL
) {

240  
NULL
;

243 
³bAdd»ss
 = 
	`psutž_g‘_³b_add»ss
(
hProûss
);

246 #ifdeà
_WIN64


247 ià(!
	`R—dProûssMemÜy
(
hProûss
, (
PCHAR
)
³bAdd»ss
 + 32,

248 &
¹lU£rProcP¬amsAdd»ss
, (
PVOID
), 
NULL
))

250 ià(!
	`R—dProûssMemÜy
(
hProûss
, (
PCHAR
)
³bAdd»ss
 + 0x10,

251 &
¹lU£rProcP¬amsAdd»ss
, (
PVOID
), 
NULL
))

255 
	`PyE¼_S‘FromWšdowsE¼
(0);

256 
”rÜ
;

260 #ifdeà
_WIN64


261 ià(!
	`R—dProûssMemÜy
(
hProûss
, (
PCHAR
)
¹lU£rProcP¬amsAdd»ss
 + 112,

262 &
commªdLše
, (commªdLše), 
NULL
))

264 ià(!
	`R—dProûssMemÜy
(
hProûss
, (
PCHAR
)
¹lU£rProcP¬amsAdd»ss
 + 0x40,

265 &
commªdLše
, (commªdLše), 
NULL
))

268 
	`PyE¼_S‘FromWšdowsE¼
(0);

269 
”rÜ
;

274 
commªdLšeCÚ‹Ás
 = (
WCHAR
 *)
	`m®loc
(
commªdLše
.
L’gth
 + 1);

275 ià(
commªdLšeCÚ‹Ás
 =ð
NULL
) {

276 
	`PyE¼_NoMemÜy
();

277 
”rÜ
;

281 ià(!
	`R—dProûssMemÜy
(
hProûss
, 
commªdLše
.
Bufãr
,

282 
commªdLšeCÚ‹Ás
, 
commªdLše
.
L’gth
, 
NULL
))

284 
	`PyE¼_S‘FromWšdowsE¼
(0);

285 
”rÜ
;

291 
commªdLšeCÚ‹Ás
[(
commªdLše
.
L’gth
 / (
WCHAR
))] = '\0';

295 
szArgli¡
 = 
	`CommªdLšeToArgvW
(
commªdLšeCÚ‹Ás
, &
nArgs
);

296 ià(
NULL
 =ð
szArgli¡
) {

299 
¬g_äom_wch¬
 = 
	`PyUnicode_FromWideCh¬
(
commªdLšeCÚ‹Ás
,

300 
commªdLše
.
L’gth
 / 2);

301 ià(
¬g_äom_wch¬
 =ð
NULL
)

302 
”rÜ
;

303 #ià
PY_MAJOR_VERSION
 >= 3

304 
¬gLi¡
 = 
	`Py_BuždV®ue
("N", 
	`PyUnicode_AsUTF8SŒšg
(
¬g_äom_wch¬
));

306 
¬gLi¡
 = 
	`Py_BuždV®ue
("N", 
	`PyUnicode_FromObjeù
(
¬g_äom_wch¬
));

308 ià(!
¬gLi¡
)

309 
”rÜ
;

314 
¬gLi¡
 = 
	`Py_BuždV®ue
("[]");

315 ià(
¬gLi¡
 =ð
NULL
)

316 
”rÜ
;

317 
i
 = 0; i < 
nArgs
; i++) {

318 
¬g_äom_wch¬
 = 
NULL
;

319 
¬g
 = 
NULL
;

320 
¬g_äom_wch¬
 = 
	`PyUnicode_FromWideCh¬
(
szArgli¡
[
i
],

321 
	`wc¦’
(
szArgli¡
[
i
]));

322 ià(
¬g_äom_wch¬
 =ð
NULL
)

323 
”rÜ
;

324 #ià
PY_MAJOR_VERSION
 >= 3

325 
¬g
 = 
	`PyUnicode_FromObjeù
(
¬g_äom_wch¬
);

327 
¬g
 = 
	`PyUnicode_AsUTF8SŒšg
(
¬g_äom_wch¬
);

329 ià(
¬g
 =ð
NULL
)

330 
”rÜ
;

331 
	`Py_XDECREF
(
¬g_äom_wch¬
);

332 ià(
	`PyLi¡_Aµ’d
(
¬gLi¡
, 
¬g
))

333 
”rÜ
;

334 
	`Py_XDECREF
(
¬g
);

338 ià(
szArgli¡
 !ð
NULL
)

339 
	`LoÿlF»e
(
szArgli¡
);

340 
	`ä“
(
commªdLšeCÚ‹Ás
);

341 
	`Clo£HªdË
(
hProûss
);

342  
¬gLi¡
;

344 
”rÜ
:

345 
	`Py_XDECREF
(
¬g
);

346 
	`Py_XDECREF
(
¬g_äom_wch¬
);

347 
	`Py_XDECREF
(
¬gLi¡
);

348 ià(
hProûss
 !ð
NULL
)

349 
	`Clo£HªdË
(
hProûss
);

350 ià(
commªdLšeCÚ‹Ás
 !ð
NULL
)

351 
	`ä“
(
commªdLšeCÚ‹Ás
);

352 ià(
szArgli¡
 !ð
NULL
)

353 
	`LoÿlF»e
(
szArgli¡
);

354  
NULL
;

355 
	}
}

358 

	#PH_FIRST_PROCESS
(
Proûs£s
è((
PSYSTEM_PROCESS_INFORMATION
)(Proûs£s))

	)

359 

	#PH_NEXT_PROCESS
(
Proûss
) ( \

360 ((
PSYSTEM_PROCESS_INFORMATION
)(
Proûss
))->
NextEÁryOff£t
 ? \

361 (
PSYSTEM_PROCESS_INFORMATION
)((
PCHAR
)(
Proûss
) + \

362 ((
PSYSTEM_PROCESS_INFORMATION
)(
Proûss
))->
NextEÁryOff£t
) : \

363 
NULL
)

	)

365 cÚ¡ 
	gSTATUS_INFO_LENGTH_MISMATCH
 = 0xC0000004;

366 cÚ¡ 
	gSTATUS_BUFFER_TOO_SMALL
 = 0xC0000023L;

374 
	$psutž_g‘_´oc_šfo
(
DWORD
 
pid
, 
PSYSTEM_PROCESS_INFORMATION
 *
»tProûss
,

375 
PVOID
 *
»tBufãr
)

377 
ULONG
 
š™ŸlBufãrSize
 = 0x4000;

378 
NTSTATUS
 
¡©us
;

379 
PVOID
 
bufãr
;

380 
ULONG
 
bufãrSize
;

381 
PSYSTEM_PROCESS_INFORMATION
 
´oûss
;

384 
	`DWORD
 (
	t_¡dÿÎ
 * 
	tNTQSI_PROC
è(, 
	tPVOID
, 
	tULONG
, 
	tPULONG
);

385 
NTQSI_PROC
 
NtQu”ySy¡emInfÜm©iÚ
;

386 
HINSTANCE
 
hNtDÎ
;

387 
hNtDÎ
 = 
	`LßdLib¿ry
(
	`TEXT
("ntdll.dll"));

388 
NtQu”ySy¡emInfÜm©iÚ
 = (
NTQSI_PROC
)
	`G‘ProcAdd»ss
(

389 
hNtDÎ
, "NtQuerySystemInformation");

391 
bufãrSize
 = 
š™ŸlBufãrSize
;

392 
bufãr
 = 
	`m®loc
(
bufãrSize
);

393 ià(
bufãr
 =ð
NULL
) {

394 
	`PyE¼_NoMemÜy
();

395 
”rÜ
;

398 
TRUE
) {

399 
¡©us
 = 
	`NtQu”ySy¡emInfÜm©iÚ
(
Sy¡emProûssInfÜm©iÚ
, 
bufãr
,

400 
bufãrSize
, &bufferSize);

402 ià(
¡©us
 =ð
STATUS_BUFFER_TOO_SMALL
 ||

403 
¡©us
 =ð
STATUS_INFO_LENGTH_MISMATCH
)

405 
	`ä“
(
bufãr
);

406 
bufãr
 = 
	`m®loc
(
bufãrSize
);

407 ià(
bufãr
 =ð
NULL
) {

408 
	`PyE¼_NoMemÜy
();

409 
”rÜ
;

417 ià(
¡©us
 != 0) {

418 
	`PyE¼_FÜm©
(
PyExc_RuÁimeE¼Ü
, "NtQuerySystemInformation() failed");

419 
”rÜ
;

422 ià(
bufãrSize
 <= 0x20000) {

423 
š™ŸlBufãrSize
 = 
bufãrSize
;

426 
´oûss
 = 
	`PH_FIRST_PROCESS
(
bufãr
);

428 ià(
´oûss
->
UniqueProûssId
 =ð(
HANDLE
)
pid
) {

429 *
»tProûss
 = 
´oûss
;

430 *
»tBufãr
 = 
bufãr
;

433 }  (
´oûss
 = 
	`PH_NEXT_PROCESS
(process)) );

435 
	`NoSuchProûss
();

436 
”rÜ
;

438 
”rÜ
:

439 
	`F»eLib¿ry
(
hNtDÎ
);

440 ià(
bufãr
 !ð
NULL
)

441 
	`ä“
(
bufãr
);

443 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_info.h

7 
	~<PythÚ.h
>

8 
	~<wšdows.h
>

10 
DWORD
* 
psutž_g‘_pids
(DWORD *
numb”OfR‘uºedPIDs
);

11 
HANDLE
 
psutž_hªdË_äom_pid
(
DWORD
 
pid
);

12 
HANDLE
 
psutž_hªdË_äom_pid_wacûss
(
DWORD
 
pid
, DWORD 
dwDesœedAcûss
);

13 
psutž_hªdËp_is_rušg
(
HANDLE
 
hProûss
);

14 
psutž_pid_š_´oþi¡
(
DWORD
 
pid
);

15 
psutž_pid_is_rušg
(
DWORD
 
pid
);

16 
PVOID
 
psutž_g‘_³b_add»ss
(
HANDLE
 
ProûssHªdË
);

17 
PyObjeù
* 
psutž_g‘_¬g_li¡
(
pid
);

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\security.c

10 
	~<wšdows.h
>

11 
	~<PythÚ.h
>

17 
HANDLE


18 
	$psutž_tok’_äom_hªdË
(
HANDLE
 
hProûss
) {

19 
HANDLE
 
hTok’
 = 
NULL
;

21 ià(! 
	`O³nProûssTok’
(
hProûss
, 
TOKEN_QUERY
, &
hTok’
)) {

22  
	`PyE¼_S‘FromWšdowsE¼
(0);

24  
hTok’
;

25 
	}
}

42 
	$psutž_has_sy¡em_´ivžege
(
HANDLE
 
hProûss
) {

43 
DWORD
 
i
;

44 
DWORD
 
dwSize
 = 0;

45 
DWORD
 
dwR‘v®
 = 0;

46 
TCHAR
 
´ivName
[256];

47 
DWORD
 
dwNameSize
 = 256;

49 
BYTE
 *
pBufãr
 = 
NULL
;

50 
TOKEN_PRIVILEGES
 *

 = 
NULL
;

51 
HANDLE
 
hTok’
 = 
	`psutž_tok’_äom_hªdË
(
hProûss
);

53 ià(
NULL
 =ð
hTok’
) {

58 ià(! 
	`G‘Tok’InfÜm©iÚ
(
hTok’
, 
Tok’Privžeges
, 
NULL
, 0, &
dwSize
)) {

59 
dwR‘v®
 = 
	`G‘La¡E¼Ü
();

61 ià(
dwR‘v®
 !ð
ERROR_INSUFFICIENT_BUFFER
 ) {

62 
	`PyE¼_S‘FromWšdowsE¼
(
dwR‘v®
);

69 
pBufãr
 = (
BYTE
 *è
	`m®loc
(
dwSize
);

70 ià(
pBufãr
 =ð
NULL
) {

71 
	`PyE¼_NoMemÜy
();

75 ià(! 
	`G‘Tok’InfÜm©iÚ
(
hTok’
, 
Tok’Privžeges
, 
pBufãr
,

76 
dwSize
, &dwSize))

78 
	`PyE¼_S‘FromWšdowsE¼
(0);

79 
	`ä“
(
pBufãr
);

84 

 = (
TOKEN_PRIVILEGES
 *)
pBufãr
;

87 
i
 = 0; i < 

->
PrivžegeCouÁ
; i++) {

89 
	`¡rýy
(
´ivName
, "");

90 
dwNameSize
 = (
´ivName
è/ (
TCHAR
);

91 ià(! 
	`LookupPrivžegeName
(
NULL
,

92 &

->
Privžeges
[
i
].
Luid
,

93 (
LPTSTR
)
´ivName
,

94 &
dwNameSize
))

96 
	`PyE¼_S‘FromWšdowsE¼
(0);

97 
	`ä“
(
pBufãr
);

102 ià(! 
	`l¡rcmpi
(
´ivName
, 
	`TEXT
("SeTcbPrivilege"))) {

103 
	`ä“
(
pBufãr
);

108 
	`ä“
(
pBufãr
);

110 
	}
}

113 
BOOL


114 
	$psutž_£t_´ivžege
(
HANDLE
 
hTok’
, 
LPCTSTR
 
Privžege
, 
BOOL
 
bEÇbËPrivžege
)

116 
TOKEN_PRIVILEGES
 

;

117 
LUID
 
luid
;

118 
TOKEN_PRIVILEGES
 
P»vious
;

119 
DWORD
 
cbP»vious
 = (
TOKEN_PRIVILEGES
);

121 ià(!
	`LookupPrivžegeV®ue
Ð
NULL
, 
Privžege
, &
luid
 )è 
FALSE
;

124 

.
PrivžegeCouÁ
 = 1;

125 

.
Privžeges
[0].
Luid
 = 
luid
;

126 

.
Privžeges
[0].
A‰ribu‹s
 = 0;

128 
	`Adju¡Tok’Privžeges
(

129 
hTok’
,

130 
FALSE
,

131 &

,

132 (
TOKEN_PRIVILEGES
),

133 &
P»vious
,

134 &
cbP»vious


137 ià(
	`G‘La¡E¼Ü
(è!ð
ERROR_SUCCESS
è 
FALSE
;

140 
P»vious
.
PrivžegeCouÁ
 = 1;

141 
P»vious
.
Privžeges
[0].
Luid
 = 
luid
;

143 ià(
bEÇbËPrivžege
) {

144 
P»vious
.
Privžeges
[0].
A‰ribu‹s
 |ð(
SE_PRIVILEGE_ENABLED
);

148 
P»vious
.
Privžeges
[0].
A‰ribu‹s
 ^=

149 (
SE_PRIVILEGE_ENABLED
 & 
P»vious
.
Privžeges
[0].
A‰ribu‹s
);

152 
	`Adju¡Tok’Privžeges
(

153 
hTok’
,

154 
FALSE
,

155 &
P»vious
,

156 
cbP»vious
,

157 
NULL
,

158 
NULL


161 ià(
	`G‘La¡E¼Ü
(è!ð
ERROR_SUCCESS
è 
FALSE
;

163  
TRUE
;

164 
	}
}

168 
	$psutž_£t_£_debug
()

170 
HANDLE
 
hTok’
;

171 ià(! 
	`O³nTh»adTok’
(
	`G‘Cu¼’tTh»ad
(),

172 
TOKEN_ADJUST_PRIVILEGES
 | 
TOKEN_QUERY
,

173 
FALSE
,

174 &
hTok’
)

176 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_NO_TOKEN
) {

177 ià(!
	`Im³rsÚ©eS–f
(
Secur™yIm³rsÚ©iÚ
)) {

178 
	`Clo£HªdË
(
hTok’
);

181 ià(!
	`O³nTh»adTok’
(
	`G‘Cu¼’tTh»ad
(),

182 
TOKEN_ADJUST_PRIVILEGES
 | 
TOKEN_QUERY
,

183 
FALSE
,

184 &
hTok’
)

186 
	`Rev”tToS–f
();

187 
	`Clo£HªdË
(
hTok’
);

194 ià(! 
	`psutž_£t_´ivžege
(
hTok’
, 
SE_DEBUG_NAME
, 
TRUE
)) {

195 
	`Rev”tToS–f
();

196 
	`Clo£HªdË
(
hTok’
);

200 
	`Rev”tToS–f
();

201 
	`Clo£HªdË
(
hTok’
);

203 
	}
}

207 
	$psutž_un£t_£_debug
()

209 
HANDLE
 
hTok’
;

210 ià(! 
	`O³nTh»adTok’
(
	`G‘Cu¼’tTh»ad
(),

211 
TOKEN_ADJUST_PRIVILEGES
 | 
TOKEN_QUERY
,

212 
FALSE
,

213 &
hTok’
)

215 ià(
	`G‘La¡E¼Ü
(è=ð
ERROR_NO_TOKEN
) {

216 ià(! 
	`Im³rsÚ©eS–f
(
Secur™yIm³rsÚ©iÚ
)) {

220 ià(!
	`O³nTh»adTok’
(
	`G‘Cu¼’tTh»ad
(),

221 
TOKEN_ADJUST_PRIVILEGES
 | 
TOKEN_QUERY
,

222 
FALSE
,

223 &
hTok’
)

232 ià(! 
	`psutž_£t_´ivžege
(
hTok’
, 
SE_DEBUG_NAME
, 
FALSE
)) {

236 
	`Clo£HªdË
(
hTok’
);

238 
	}
}

	@E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\security.h

10 
	~<wšdows.h
>

12 
BOOL
 
psutž_£t_´ivžege
(
HANDLE
 
hTok’
, 
LPCTSTR
 
Privžege
, BOOL 
bEÇbËPrivžege
);

13 
HANDLE
 
psutž_tok’_äom_hªdË
(HANDLE 
hProûss
);

14 
psutž_has_sy¡em_´ivžege
(
HANDLE
 
hProûss
);

15 
psutž_£t_£_debug
();

16 
psutž_un£t_£_debug
();

	@
1
.
0
46
3505
E:\GitHub\ChromeFuzzer\PocSmplify\GrayHatPython-master\ghpython_src\src\addnum.cpp
E:\GitHub\ChromeFuzzer\PocSmplify\GrayHatPython-master\ghpython_src\src\ghp_inject.cpp
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\Exception.c
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\Exception.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\MacDll.c
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\MacDll.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\MacX.c
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\dyld.c
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\dyld.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\implementation.c
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\implementation.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\main.c
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\MacOSX\macdll\windows.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\olly_callbacks.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\olly_redefines.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\paimei_ollydbg_connector.cpp
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\paimei_ollydbg_connector.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\plugin.h
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\stdafx.cpp
E:\GitHub\ChromeFuzzer\PocSmplify\paimei-master\ollydbg_connector\stdafx.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_bsd.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_bsd.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_common.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_common.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_linux.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_linux.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_osx.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_osx.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_posix.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_posix.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_sunos.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_sunos.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_windows.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\_psutil_windows.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\bsd\process_info.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\bsd\process_info.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\osx\process_info.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\osx\process_info.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\glpi.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\ntextapi.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_handles.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_handles.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_info.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\process_info.h
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\security.c
E:\GitHub\ChromeFuzzer\PocSmplify\psutil-master\psutil\arch\windows\security.h