إذا كتبت يوماً أداة صغيرة تشغل أمراً آخر وتقرأ مخرجه، مثل سكربت بناء Build Script يشغل المترجم Compiler ثم يحلل رسائله، أو خدمة تشغل أداة ضغط ملفات وتنتظر انتهاءها، فغالب الظن أنك قابلت هذا الموقف: الأداة تعمل ممتازة مع الأوامر القصيرة، ثم تتجمد فجأة مع أمر يطبع مخرجاً طويلاً، فلا هي تنتهي ولا هي تطبع خطأ، والبرنامج الابن يظهر في مدير المهام Task Manager وهو لا يستهلك شيئاً من المعالج. وفي يوم آخر تحاول الأداة نفسها حذف ملف مؤقت كتبته قبل لحظات فيرفض Windows بحجة أن الملف مفتوح، مع أنك أغلقته بنفسك في السطر السابق. وهذه المشاكل لا تأتي من خطأ في منطق برنامجك، وإنما من تفاصيل في ثلاث دوال يستعملها كل برنامج على Windows ولو لم يكتبها بيده: CreateProcessW لتشغيل برنامج آخر، وCreateThread لتشغيل كود بالتوازي داخل البرنامج نفسه، وCreateFileW لفتح الملفات والأنابيب والأجهزة.
وهذا المقال من مرحلة Windows للمطورين، ويأتي بعد مقال واجهة Win32 الذي شرح كيف يقرأ المطور توقيع الدالة وكيف يتعامل مع رموز الأخطاء عبر GetLastError، ومقال أول نافذة Win32 الذي بنى نافذة وحلقة رسائل. أما هنا فنترك النوافذ جانباً، ونكتب بلغة C برامج صغيرة تشغل برامج أخرى وتتبادل معها البيانات وتفتح الملفات، ونشغلها على جهاز Windows 11 حقيقي بصلاحيات مستخدم عادي Standard User، ونقرأ ما تقوله كل دالة سطراً سطراً. وكل رقم في المقال جاء من المختبر Lab المرفق مع المقال، لا من مثال مخترع.
دليلواجهة Win32 API: كيف يكلم برنامجك نظام Windows؟نقرأ واجهة Win32 ببرامج C صغيرة على Windows 11: أين يعيش كود الدوال، ولماذا يتلف الاسم العربي مع نسخة A، وكيف تقرأ GetLastError وHRESULT دون أن يخدعك رقم قديم.
دليلأول برنامج Win32 بلغة C: نافذة وحلقة الرسائلنكتب نافذة Win32 بلغة C ونسجل كل رسالة تصلها، ثم نجعلها عربية بـ WS_EX_LAYOUTRTL ونرى لماذا يعلن Windows بعد خمس ثوان أن البرنامج لا يستجيب.
دليلالمكتبات المشتركة DLL: التحميل وترتيب البحث وDLL Hellنبني مكتبة DLL صغيرة بأنفسنا ونراقب المحمل وهو يقرأ جداولها ويحملها ويستدعي DllMain، ثم نرى من أين جاء جحيم المكتبات وكيف عزله Windows بالنسخ جنباً إلى جنب.
دليلالعمليات والخيوط وكائنات Job في Windowsنقيس بلغة C على Windows 11 كيف يختار المجدول الخيط الذي يعمل، ولماذا تكفي درجة أولوية واحدة لتجويع برنامج، وكيف تضع كائنات Job سقفاً للمعالج وتنهي شجرة العمليات كلها.وسوف نناقش في هذا المقال ما يلي:
- العملية Process والخيط Thread والمقبض Handle: ثلاث كلمات تحتاجها قبل أي سطر كود.
CreateProcessWمن جهة البرنامج الأب: ما الذي يعود إليك، ولماذا يجب أن يكون سطر الأوامر في ذاكرة قابلة للكتابة، وماذا يحدث عندما ينسى المطور علامات التنصيص حول مسار فيه مسافة.- قراءة مخرج البرنامج الابن عبر أنبوب Pipe، والخطآن اللذان يجمدان الأدوات: طرف كتابة لم يغلق، وانتظار الابن قبل القراءة.
- توريث المقابض Handle Inheritance: كيف يصل ملف لم تقصده إلى البرنامج الابن، وكيف تحدد بالضبط ما يرثه.
CreateThreadوأربعة خيوط تزيد عداداً واحداً، وأين ذهب أكثر من نصف الزيادات.CreateFileWوReadFileوWriteFile: قيم الإنشاء ورموز الأخطاء التي تقابلها كل يوم، والنص العربي بترميز UTF-8، والقراءة غير المتزامنة Overlapped I/O، وتسرب المقابض Handle Leak.- الأخطاء الشائعة، وجدول قرار سريع، وتدريب عملي.
العملية والخيط والمقبض: ثلاث كلمات قبل أي كود
العملية Process في Windows هي حاوية لا تنفذ شيئاً بنفسها، وإنما تجمع ما يحتاجه البرنامج ليعمل: مساحة عناوين Address Space خاصة بها لا يراها غيرها، وجدول مقابض Handle Table فيه كل ما فتحته من ملفات وأقفال وعمليات أخرى، ورمز أمان Access Token يحدد صلاحياتها. والذي ينفذ الكود فعلاً هو الخيط Thread، وكل عملية تبدأ بخيط واحد يسمى الخيط الأول Primary Thread، ثم تنشئ ما تشاء من الخيوط الأخرى، وكلها تتشارك الذاكرة نفسها والمقابض نفسها. ولذلك فإن خطأ في خيط واحد يكفي لإسقاط العملية كلها، وخيطان يكتبان في المتغير نفسه دون تنسيق يفسد أحدهما عمل الآخر، كما سوف نرى في المختبر بالأرقام.
أما المقبض Handle فهو رقم صغير تعطيه النواة Kernel لبرنامجك عندما يفتح كائناً Object: ملفاً أو عملية أو خيطاً أو أنبوباً أو حدثاً Event. والرقم نفسه لا يحمل أي معنى خارج العملية التي حصلت عليه، فهو موقع في جدول مقابضها هي، والنواة هي التي تعرف أي كائن يقابله. وقد شرحنا في مقال كيف يعمل Windows من الداخل كيف تنزل كل دالة من هذه الدوال من kernelbase.dll إلى ntdll.dll ثم إلى النواة عبر استدعاء النظام System Call، فلن نعيد ذلك هنا. وما يهمنا في هذا المقال هو قاعدة واحدة تتكرر في كل قسم: كل دالة تبدأ بكلمة Create تعطيك مقبضاً أو أكثر، وكل مقبض تأخذه يجب أن تغلقه بالدالة CloseHandle عندما تنتهي منه، والسبب أن الكائن يبقى حياً في النواة ما دام له مقبض مفتوح واحد على الأقل، حتى لو انتهى البرنامج الذي يمثله.
وقد يتساءل البعض: لماذا لا يكتفي Windows بالفكرة المعروفة في Linux، حيث تنسخ الدالة fork العملية كلها ثم تستبدل الدالة exec البرنامج؟ والإجابة أن فريق Windows NT اختار من البداية دالة واحدة تنشئ العملية وتحمل البرنامج فيها في خطوة واحدة، وتأخذ كل الإعدادات في معاملاتها: سطر الأوامر، والمقابض التي يرثها الابن، والمجلد الحالي، ومتغيرات البيئة Environment Variables، والأولوية، وشكل النافذة. ولذلك تبدو CreateProcessW مخيفة بمعاملاتها العشرة، ولكنها في الحقيقة تجمع في استدعاء واحد ما يفعله برنامج Linux في عدة أسطر بين fork وexec. ومن يريد التفصيل الكامل لما يحدث داخل النواة خطوة خطوة فقد شرحه كتاب Windows Internals في طبعته السابعة، الجزء الأول، في فصل العمليات والمهام Processes and Jobs تحت عنوان مسار CreateProcess، وصفحة الكتاب في موقع Sysinternals.
تجهيز المختبر Lab
المختبر خمسة برامج صغيرة بلغة C، كل منها يجرب جانباً واحداً، وبرنامج سادس اسمه child.exe يلعب دور البرنامج الآخر في كل التجارب: يطبع رقم عمليته PID والملف الذي شغل منه وسطر الأوامر الذي وصله وجملة عربية، ثم يفعل ما تطلبه منه المعاملات، فيخرج برمز محدد، أو ينتظر مدة، أو يكتب كمية كبيرة من البيانات، أو يفحص هل يملك مقبضاً برقم معين. ولا نحتاج إلى تثبيت أي مترجم على Windows، فالبناء يتم بمترجم MinGW-w64 GCC داخل Container مؤقت من Alpine يحذف نفسه بعد الانتهاء:
docker run --rm -v "%cd%:/src" -w /src alpine:3.22 sh build.shوالملف build.sh يثبت المترجم داخل الـ Container ثم يبني البرامج الخمسة:
#!/bin/sh
set -e
command -v x86_64-w64-mingw32-gcc >/dev/null || apk add -q mingw-w64-gcc >/dev/null
x86_64-w64-mingw32-gcc --version | head -1
mkdir -p build
for p in child spawn pipe files; do x86_64-w64-mingw32-gcc -municode -O1 -Wall -o build/$p.exe $p.c -lshell32; done
x86_64-w64-mingw32-gcc -O1 -Wall -o build/threads.exe threads.c
ls -l buildثم يشغل السكربت run.ps1 في Windows PowerShell 5.1 الملفات المرقمة بالترتيب، وكل منها يكتب مخرجه في ملف out-*.txt بجانبه، بعد أن يستبدل اسم المستخدم واسم الجهاز ومسار مجلد المختبر بأسماء عامة مثل C:\lab:
powershell -NoProfile -ExecutionPolicy Bypass -File run.ps1وفي الملف المشترك lib.ps1 سطر مهم يجب أن تعرف لماذا وضعناه: السكربت يستدعي الدالة SetErrorMode بالقيمتين SEM_FAILCRITICALERRORS وSEM_NOGPFAULTERRORBOX، وهذا الوضع يرثه كل برنامج يشغله السكربت، والسبب أن إحدى التجارب تسقط برنامجاً عمداً، ولولا هذا السطر لظهرت نافذة خطأ على سطح المكتب تنتظر من يغلقها. والسكربت لا يحتاج صلاحيات المدير Administrator، ولا يغير شيئاً في السجل Registry، وكل ما ينشئه داخل مجلد واحد في %TEMP% يحذفه السكربت الأخير 99-cleanup.ps1. وهذه بيئة التشغيل كما طبعها السكربت الأول:
OS : Microsoft Windows 11 Pro 24H2 (build 26100.9711)
CPU : 8 logical processors
PowerShell: 5.1.26100.9711
Elevated : False
Lab folder: C:\lab
child.exe 68289 bytes
files.exe 72127 bytes
my.exe 68289 bytes
pipe.exe 71486 bytes
spawn.exe 65952 bytes
threads.exe 63098 bytes
my app\child.exe 68289 bytesولاحظ في القائمة نسختين إضافيتين من child.exe: واحدة داخل مجلد اسمه my app فيه مسافة، وأخرى باسم my.exe في المجلد الرئيسي للمختبر. وهاتان النسختان هما محور تجربة علامات التنصيص التي سوف نصل إليها بعد قليل.
تشغيل برنامج آخر: CreateProcessW
الدالة CreateProcessW تأخذ عشرة معاملات، ولكن ستة منها تمرر لها NULL أو FALSE أو صفراً في أغلب البرامج. والجزء الأساسي من البرنامج spawn.c هو الدالة التالية، التي تشغل أمراً وتنتظره وتطبع كل ما عرفه الأب عن الابن:
static DWORD run(const wchar_t *app, const wchar_t *cmd) {
wchar_t buf[1024]; wcscpy(buf, cmd); // CreateProcessW may write into this buffer
STARTUPINFOW si = { sizeof si }; PROCESS_INFORMATION pi;
if (!CreateProcessW(app, buf, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
DWORD e = GetLastError(); out(L"parent: CreateProcessW failed, error %lu\n", e); return e;
}
DWORD code; GetExitCodeProcess(pi.hProcess, &code);
out(L"parent: pid %lu, tid %lu, hProcess 0x%llX, hThread 0x%llX, exit code right away %lu (STILL_ACTIVE = 259)\n", ...);
DWORD w = WaitForSingleObject(pi.hProcess, 10000);
GetExitCodeProcess(pi.hProcess, &code);
...
CloseHandle(pi.hThread); CloseHandle(pi.hProcess);
return code;
}وعند تشغيل التجربة الأولى، التي تطلب من الابن أن ينتظر 300 ms ثم يخرج بالرمز 7، كان المخرج كما يلي:
> spawn.exe basic
parent: CreateProcessW(app=NULL, cmd=["C:\lab\child.exe" --sleep 300 --exit 7])
parent: pid 43556, tid 24916, hProcess 0xC4, hThread 0xC0, exit code right away 259 (STILL_ACTIVE = 259)
child: pid 43556, file C:\lab\child.exe
child: command line ["C:\lab\child.exe" --sleep 300 --exit 7]
child: مرحباً من العملية الابن
child: exiting with code 7
parent: wait returned 0, exit code 7 (0x00000007), lived 360 msوفي المخرج أعلاه لاحظ التالي:
- الدالة أعادت أربعة أشياء في
PROCESS_INFORMATION: رقم العملية 43556، ورقم خيطها الأول 24916، ومقبضين:0xC4للعملية و0xC0للخيط. والرقمان الأولان للعرض والتعريف فقط، أما المقبضان فهما ما تستعمله فعلاً للانتظار وقراءة رمز الخروج، والسبب أن رقم العملية PID قد يعاد استعماله لعملية أخرى بعد خروج الأولى، بينما المقبض يبقى مرتبطاً بالكائن نفسه حتى تغلقه. - رقم العملية عند الابن هو نفسه عند الأب: طبع الابن 43556، وهذا يؤكد أن الرقم ثابت للنظام كله، بخلاف المقبض الذي يخص جدول الأب وحده.
- الدالة لا تنتظر الابن: رمز الخروج لحظة العودة كان 259، وهي القيمة
STILL_ACTIVE، أي أن الابن ما زال يعمل. والانتظار مسؤوليتك أنت بالدالةWaitForSingleObject، التي أعادت صفراً، وهوWAIT_OBJECT_0، أي أن العملية انتهت قبل مهلة العشر ثوان. - رمز الخروج 7 وصل كما هو: بعد الانتظار أعادت
GetExitCodeProcessالرقم الذي أعاده الابن منwmain، وعاش الابن 360 ms، منها 300 ms انتظار طلبناه، والباقي زمن إنشاء العملية وتحميل البرنامج والمكتبات. - الجملة العربية وصلت سليمة: الابن يكتب مخرجه بترميز UTF-8 بالدالة
WriteFileمباشرة، والسكربت يقرؤه بالترميز نفسه، ولو اختلف الترميزان لظهرت الجملة حروفاً غريبة كما سوف نرى في قسم الملفات.
وهناك فخ صغير في 259 يجب أن تعرفه: إذا خرج برنامج بالرمز 259 نفسه فلن تستطيع أن تفرق بينه وبين برنامج ما زال يعمل إذا اكتفيت بالدالة GetExitCodeProcess، وتذكر ذلك صفحتها في Microsoft Learn صراحة، ولذلك لا تستعمل هذه الدالة لتسأل هل انتهى البرنامج، وإنما اسأل بالدالة WaitForSingleObject بمهلة صفر، ثم اقرأ رمز الخروج بعد أن تعرف أنه انتهى.

لماذا يجب أن يكون سطر الأوامر في ذاكرة قابلة للكتابة؟
لاحظ في الدالة run أعلاه أننا ننسخ سطر الأوامر إلى مصفوفة buf قبل أن نمرره، ولم نمرر النص مباشرة. والسبب سطر في وثائق الدالة يتجاهله كثير من المطورين: النسخة CreateProcessW قد تعدل محتوى هذا النص أثناء عملها، ولذلك لا يجوز أن يكون في ذاكرة للقراءة فقط Read-only Memory، مثل نص ثابت Literal String في الكود، وإلا فقد تسبب الدالة خطأ وصول للذاكرة Access Violation. وقد شرح Raymond Chen السبب في مقاله Why does the CreateProcess function modify its input command line? في مدونة The Old New Thing: الدالة تحتاج أن تفصل اسم البرنامج عن باقي السطر، فتضع مؤقتاً حرف نهاية النص مكان المسافة، ثم تعيد المسافة بعد أن تنتهي، وهي طريقة رخيصة لا تحتاج نسخة جديدة من النص، ولكنها تفترض أن الذاكرة قابلة للكتابة.
ولكي نرى ذلك لا أن نقرأه فقط، كتبنا في spawn.c وضعاً اسمه literal يمرر النص الثابت L"child.exe --exit 4" مباشرة، وشغلناه كبرنامج ابن من الوضع crash حتى نقرأ ما يحدث له من الخارج:
> spawn.exe crash
parent: CreateProcessW(app=NULL, cmd=["C:\lab\spawn.exe" literal])
parent: pid 40552, tid 31096, hProcess 0x94, hThread 0x64, exit code right away 259 (STILL_ACTIVE = 259)
parent: passing a literal string as lpCommandLine
parent: wait returned 0, exit code 3221225477 (0xC0000005), lived 18 msوالمخرج واضح: البرنامج الذي مرر النص الثابت طبع سطره الأول ثم مات بعد 18 ms دون أن يطبع نتيجة CreateProcessW، ورمز خروجه 0xC0000005 هو STATUS_ACCESS_VIOLATION، أي أن الدالة حاولت الكتابة في ذاكرة للقراءة فقط فأسقطت البرنامج كله. ولم تظهر نافذة خطأ على الشاشة لأن السكربت ورث البرنامج وضع SetErrorMode الذي ذكرناه. ولاحظ أن هذا الخطأ لا يظهر في كل مترجم بالطريقة نفسها، فبعض المترجمات تضع النصوص الثابتة في ذاكرة قابلة للكتابة، فيعمل الكود الخاطئ سنوات عند مطور ثم يسقط عند آخر بعد تغيير إعداد واحد، ولذلك اجعلها قاعدة ثابتة: انسخ سطر الأوامر دائماً إلى مصفوفة خاصة به قبل أن تمرره.
المسافة وعلامات التنصيص: أي ملف يشغل Windows فعلاً؟
عندما يكون المعامل الأول lpApplicationName فارغاً، يأخذ Windows اسم البرنامج من بداية سطر الأوامر حتى أول مسافة، فإذا كان المسار نفسه فيه مسافة ولم يضعه المطور بين علامتي تنصيص، فإن Windows لا يعرف أين ينتهي اسم الملف وأين تبدأ المعاملات. وتشرح وثائق الدالة ما يفعله في هذه الحالة بمثال c:\program files\sub dir\program name: يجرب أولاً c:\program.exe، ثم c:\program files\sub.exe، وهكذا مع كل مسافة حتى يجد ملفاً موجوداً. ولهذا وضعنا في مجلد المختبر الملف my.exe بجانب المجلد my app، ثم شغلنا الابن نفسه بثلاث طرق:
> spawn.exe unquoted
parent: CreateProcessW(app=NULL, cmd=[C:\lab\my app\child.exe --exit 1])
parent: pid 35740, tid 29028, hProcess 0xC0, hThread 0xBC, exit code right away 259 (STILL_ACTIVE = 259)
child: pid 35740, file C:\lab\my.exe
child: command line [C:\lab\my app\child.exe --exit 1]
child: مرحباً من العملية الابن
child: exiting with code 1
parent: wait returned 0, exit code 1 (0x00000001), lived 37 ms
parent: CreateProcessW(app=NULL, cmd=["C:\lab\my app\child.exe" --exit 2])
parent: pid 44212, tid 39940, hProcess 0xF4, hThread 0xF0, exit code right away 259 (STILL_ACTIVE = 259)
child: pid 44212, file C:\lab\my app\child.exe
child: command line ["C:\lab\my app\child.exe" --exit 2]
...
parent: CreateProcessW(app=C:\lab\my app\child.exe, cmd=[child.exe --exit 3])
parent: pid 23104, tid 14404, hProcess 0xF0, hThread 0xF4, exit code right away 259 (STILL_ACTIVE = 259)
child: pid 23104, file C:\lab\my app\child.exe
child: command line [child.exe --exit 3]وفي المخرج أعلاه لاحظ التالي:
- دون علامات تنصيص شغل Windows ملفاً آخر: في المحاولة الأولى طبع الابن أن ملفه
C:\lab\my.exe، لا الملف الذي قصدناه داخلmy app، ولم يظهر أي خطأ أو تحذير، والأب يظن أن كل شيء تم كما أراد. ولو كانmy.exeبرنامجاً وضعه مخترق لعمل بصلاحيات البرنامج الأب كاملة. - البرنامج الخطأ يرى سطر الأوامر الأصلي: لاحظ أن
my.exeاستلم النص كما هو، بما فيهmy app\child.exe، أي أن البرنامج المزروع يستطيع أن يشغل البرنامج الحقيقي بعده بالمعاملات نفسها، فلا يلاحظ أحد شيئاً. - علامتا التنصيص تحلان المشكلة: في المحاولة الثانية وضعنا المسار بين علامتي تنصيص، فشغل Windows الملف الصحيح مباشرة.
- المسار الكامل في المعامل الأول يحلها أيضاً: في المحاولة الثالثة مررنا المسار في
lpApplicationName، فلم يبحث Windows عن شيء، وأصبح سطر الأوامر مجرد نص يقرؤه الابن، حتى أن أولهchild.exeفقط دون مسار.
وهذا ليس خطأ نظرياً، فالمسارات تحت C:\Program Files فيها مسافة دائماً، والخدمات Services التي يكتب مسارها في السجل دون علامات تنصيص كانت لسنوات طريقاً معروفاً لرفع الصلاحيات، حتى أن إطار MITRE ATT&CK يصنفها أسلوباً مستقلاً باسم Path Interception by Unquoted Path (T1574.009): يضع المخترق ملفاً باسم Program.exe في جذر القرص إذا وجد صلاحية كتابة فيه، فيشغله Windows مكان البرنامج الحقيقي. وأسلوب المكتبات المقابل له، أي أن يحمل البرنامج مكتبة DLL مزروعة بدل الأصلية، هو موضوع مقال اختطاف المكتبات DLL Hijacking في هذه المرحلة.

وقد يتساءل البعض: إذا كان اسم الملف دون مسار، مثل child.exe وحده، فأين يبحث Windows عنه؟ والإجابة في الوثائق نفسها: في مجلد البرنامج الأب أولاً، ثم المجلد الحالي Current Directory، ثم مجلد النظام System32، ثم مجلد Windows، ثم المجلدات المكتوبة في PATH. ولذلك عمل الوضع literal قبل أن يسقط، فالابن موجود في مجلد الأب، ولذلك أيضاً لا تعتمد على هذا البحث في أي برنامج يعمل بصلاحيات عالية، ومرر المسار الكامل دائماً.
لماذا تغلق hProcess وhThread؟
آخر سطر في الدالة run يغلق المقبضين، وهذا ليس ترتيباً شكلياً. فالعملية بعد خروجها لا تختفي من النواة ما دام لأحد مقبض مفتوح عليها، وتبقى كائناً صغيراً يحفظ رمز خروجها وأزمنتها، وهذا بالضبط ما سمح للأب أن يقرأ رمز الخروج 7 بعد انتهاء الابن. والمشكلة تبدأ مع برنامج يعمل أياماً، مثل خدمة تشغل أداة كل دقيقة ولا تغلق المقابض، فيتجمع في النواة آلاف الكائنات لعمليات انتهت منذ زمن. وإذا كنت لا تحتاج مقبض الخيط أصلاً، وهذا هو الغالب، فأغلقه مباشرة بعد CreateProcessW، ولا تؤجله.
قراءة مخرج البرنامج الابن: الأنبوب Pipe
الطريقة التي يقرأ بها برنامج مخرج برنامج آخر في Windows هي الأنبوب المجهول Anonymous Pipe: تنشئ الدالة CreatePipe كائناً واحداً له طرفان، طرف قراءة Read End وطرف كتابة Write End، فما يكتب في الثاني يقرأ من الأول بالترتيب نفسه. ثم يعطي الأب طرف الكتابة للابن ليكون مخرجه القياسي Standard Output، ويحتفظ هو بطرف القراءة. وتشرح Microsoft الخطوات كاملة في صفحة Creating a Child Process with Redirected Input and Output، وبرنامجنا pipe.c يتبعها، وهذا الجزء الذي يجهز الأنبوب ويشغل الابن:
SECURITY_ATTRIBUTES sa = { sizeof sa, NULL, TRUE }; // bInheritHandle = TRUE for both ends
CreatePipe(&rd, &wr, &sa, 0);
SetHandleInformation(rd, HANDLE_FLAG_INHERIT, 0); // the child needs only the write end
static PROCESS_INFORMATION start(wchar_t *cmd, BOOL inherit, LPPROC_THREAD_ATTRIBUTE_LIST list) {
STARTUPINFOEXW si = { { sizeof si } };
if (list) si.StartupInfo.cb = sizeof si, si.lpAttributeList = list;
si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
si.StartupInfo.hStdOutput = wr; si.StartupInfo.hStdError = wr;
si.StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
PROCESS_INFORMATION pi = { 0 };
if (!CreateProcessW(NULL, cmd, NULL, NULL, inherit, CREATE_NO_WINDOW | (list ? EXTENDED_STARTUPINFO_PRESENT : 0), NULL, NULL, &si.StartupInfo, &pi))
out(L"parent: CreateProcessW failed, error %lu\n", GetLastError());
return pi;
}وفي الكود أعلاه لاحظ التالي:
- الطرفان قابلان للتوريث عند الإنشاء: القيمة
TRUEفيSECURITY_ATTRIBUTESتجعل المقبضين قابلين للتوريث Inheritable، ثم نزيل هذه الصفة عن طرف القراءة بالدالةSetHandleInformation، لأن الابن لا يحتاجه، ولو ورثه لبقي في الابن طرف قراءة لا يقرأ منه أحد. - الراية
STARTF_USESTDHANDLES: دونها يتجاهل Windows الحقولhStdOutputوhStdErrorوhStdInputفيSTARTUPINFO، فيكتب الابن في نافذة الأب كأن شيئاً لم يكن. - المعامل الخامس
bInheritHandles: يجب أن يكونTRUEحتى يصل طرف الكتابة إلى الابن، وهذا المعامل نفسه هو مصدر مشكلة التوريث التي سوف نراها في القسم التالي. - الراية
CREATE_NO_WINDOW: الابن برنامج سطر أوامر Console، ودون هذه الراية سوف يفتح Windows له نافذة سوداء تظهر وتختفي، وهذا ما يزعج المستخدم في كثير من الأدوات.
والآن ثلاث تجارب على هذا الأنبوب. الأولى تتبع الطريقة الصحيحة: الأب يغلق نسخته من طرف الكتابة مباشرة بعد تشغيل الابن، ثم يقرأ في خيط مستقل حتى تعود ReadFile بالفشل. والثانية تنسى هذا السطر فقط. والثالثة تطلب من الابن أن يكتب 256 KB، والأب ينتظر خروج الابن قبل أن يبدأ القراءة. وهذا المخرج كاملاً:
> pipe.exe ok
parent: pipe read end 0xB0, write end 0xB4
parent: closed its own copy of the write end
reader: ReadFile ended with error 109 after 292 bytes in 2 reads
parent: reader finished after 63 ms, child has exited
parent: first bytes from the child:
child: pid 27720, file C:\lab\child.exe
child: command line ["C:\lab\child.exe" --exit 0]
child: مرحباً من العملية الابن
child: exiting with code 0
> pipe.exe keep
parent: pipe read end 0xB8, write end 0xBC
parent: reader STILL BLOCKED after 3016 ms, child has exited
parent: closing the forgotten write end now
reader: ReadFile ended with error 109 after 292 bytes in 4 reads
parent: reader finished after 3016 ms
> pipe.exe waitfirst
parent: pipe read end 0xB0, write end 0xB4
parent: WaitForSingleObject(child, 3000) = WAIT_TIMEOUT after 3016 ms; the child wrote 3 KB of 256 and is blocked in WriteFile
reader: ReadFile ended with error 109 after 262520 bytes in 255 reads
parent: after reading, the child exited after 3172 ms in totalوفي المخرج أعلاه لاحظ التالي:
- نهاية الأنبوب ليست صفراً: في الملفات تعود
ReadFileبالنجاح وصفر بايت عند نهاية الملف، أما في الأنبوب فتعود بالفشل والخطأ 109، واسمهERROR_BROKEN_PIPE، وهذا يحدث عندما يغلق آخر طرف كتابة في النظام كله. ولذلك يجب أن يعتبر كودك الخطأ 109 نهاية طبيعية للقراءة، لا خطأ يكتب في السجل. - الحالة الأولى انتهت في 63 ms: قرأ الأب 292 بايت في قراءتين، وهي الأسطر الخمسة التي طبعها الابن، ووصلت الجملة العربية سليمة لأن الأب يحول البايتات من UTF-8 قبل أن يطبعها.
- الحالة الثانية علقت مع أن الابن خرج: بعد ثلاث ثوان كان الابن قد انتهى منذ زمن، والخيط القارئ ما زال ينتظر داخل
ReadFile. والسبب أن الأب نفسه يملك نسخة مفتوحة من طرف الكتابة، فالنظام لا يستطيع أن يعرف أن أحداً لن يكتب بعد الآن، وقد يكون الأب نفسه هو الذي سوف يكتب. وبمجرد أن أغلق الأب هذه النسخة عادتReadFileبالخطأ 109 فوراً. وهذا هو السبب الأكثر شيوعاً لأداة تتجمد بعد أن ينهي البرنامج الذي شغلته عمله، والجملة التي تحذر منه في صفحة Microsoft تقول إن الأب إذا لم يغلق مقابض الأنبوب التي لا يحتاجها فلا توجد طريقة ليعرف أن الابن انتهى. - الحالة الثالثة انتظر فيها كل منهما الآخر: الأب انتظر خروج الابن ثلاث ثوان، والابن لم يكتب إلا 3 KB من 256 ثم توقف داخل
WriteFile. والسبب أن الأنبوب له مخزن Buffer صغير في النواة، طلبنا حجمه الافتراضي بتمرير صفر، فلما امتلأ توقف الكاتب ينتظر من يقرأ، والقارئ الوحيد ينتظر خروج الكاتب، وهذه حالة الجمود المتبادل Deadlock بعينها. وبمجرد أن بدأ الأب القراءة أكمل الابن الـ 256 KB كلها وخرج، وكان المجموع 262,520 بايت في 255 قراءة.
والدرس من الحالة الثالثة أن الأدوات التي تعمل مع الأوامر القصيرة وتتجمد مع الطويلة غالباً تقع في هذا الخطأ، فالأمر القصير يطبع أقل من حجم المخزن ويخرج، فيبدو الكود صحيحاً في كل اختبار صغير. والحل ألا تنتظر الابن قبل القراءة أبداً: اقرأ حتى نهاية الأنبوب، ثم انتظر الابن، وإذا كان الابن يكتب في المخرج القياسي ومخرج الأخطاء Standard Error في أنبوبين منفصلين فاقرأ كلا منهما في خيط مستقل، لأن قراءة أحدهما حتى نهايته قد تترك الآخر يمتلئ.

System.Diagnostics.Process في .NET أو subprocess في Python، فالمشكلة نفسها موجودة تحتها. فالقراءة بالأمر StandardOutput.ReadToEnd() بعد WaitForExit() تقع في الحالة الثالثة نفسها مع أي برنامج يطبع أكثر من حجم المخزن، وتوصي وثائق .NET بأن تقرأ أولاً ثم تنتظر.توريث المقابض Handle Inheritance: ما الذي يصل إلى الابن؟
عندما تمرر TRUE في المعامل bInheritHandles، لا يرث الابن طرف الأنبوب الذي تقصده فقط، وإنما ينسخ Windows إلى جدول مقابضه كل مقبض في الأب موسوم بأنه قابل للتوريث، بالرقم نفسه. وتشرح ذلك صفحة Inheritance في Microsoft Learn. وقد رأينا في مقال Process Explorer نتيجة هذا من الخارج، عندما وجدنا في مقابض برنامج الاختبار ملف سجل لم يفتحه أبداً، ورثه من ثلاثة أجيال قبله. أما هنا فنرى المسألة من جهة المطور الذي يكتب الأب.
في التجربة leak يفتح الأب ملفاً اسمه secret.txt لغرض لا علاقة له بالابن، ولكنه يفتحه قابلاً للتوريث، وهذا يحدث كثيراً في الكود الحقيقي، لأن بعض المكتبات تجعل المقابض قابلة للتوريث افتراضياً، أو لأن المطور نسخ SECURITY_ATTRIBUTES نفسها من كود الأنبوب. ثم يشغل الابن ويطلب منه أن يفحص هل يملك مقبضاً بالرقم نفسه، وبعد نصف ثانية يغلق الأب ملفه ويحاول حذفه. وفي التجربة list نفعل الشيء نفسه، ولكن مع قائمة صريحة بالمقابض التي يجب أن يرثها الابن:
> pipe.exe leak
parent: pipe read end 0xB4, write end 0xB8
parent: opened secret.txt (inheritable) as handle 0xBC
parent: closed its handle to secret.txt; DeleteFileW while the child runs = 0 (error 32)
reader: ReadFile ended with error 109 after 437 bytes in 4 reads
parent: DeleteFileW after the child exited = 1
parent: what the child printed:
child: pid 27284, file C:\lab\child.exe
child: command line ["C:\lab\child.exe" --probe BC --sleep 1500]
child: مرحباً من العملية الابن
child: handle 0xBC is open here and points to \\?\C:\lab\secret.txt
child: exiting with code 0
> pipe.exe list
parent: pipe read end 0xB0, write end 0xB4
parent: opened secret.txt (inheritable) as handle 0xB8
parent: handle list = { write end 0xB4 } only
parent: closed its handle to secret.txt; DeleteFileW while the child runs = 1 (error 0)
reader: ReadFile ended with error 109 after 355 bytes in 3 reads
parent: what the child printed:
child: pid 41188, file C:\lab\child.exe
child: command line ["C:\lab\child.exe" --probe B8 --sleep 1500]
child: مرحباً من العملية الابن
child: handle 0xB8 is open here, but it is not a file (GetFinalPathNameByHandleW error 6, GetFileType 0)
child: exiting with code 0وفي المخرج أعلاه لاحظ التالي:
- الابن وجد الملف بالرقم نفسه: في التجربة الأولى فتح الأب الملف بالمقبض
0xBC، والابن الذي لم يفتح أي ملف وجد في جدوله المقبض0xBCنفسه يشير إلىsecret.txt. وهذا يعني أن أي برنامج تشغله بهذه الطريقة يستطيع أن يقرأ ويكتب في ملفات لم تقصد أن تعطيه إياها، وهذه مشكلة أمنية حقيقية إذا كان الابن برنامجاً لا تثق به بالكامل، مثل أداة من طرف ثالث أو إضافة Plugin. - الملف لم يحذف مع أن الأب أغلقه: حاول الأب حذف الملف بعد أن أغلق مقبضه، فرفض Windows بالخطأ 32
ERROR_SHARING_VIOLATION، لأن نسخة الابن ما زالت مفتوحة بوضع مشاركة لا يسمح بالحذف. ونجح الحذف فقط بعد خروج الابن. وهذا هو سبب الموقف الذي بدأنا به المقال: «أغلقت الملف بنفسي ويقول إنه مفتوح». وقد شرحنا أوضاع المشاركة Share Modes ومعنى الخطأ 32 بالتفصيل في مقال الملف مفتوح في برنامج آخر. - القائمة الصريحة منعت التسرب: في التجربة الثانية وضعنا طرف الكتابة وحده في قائمة المقابض، فلم يصل الملف إلى الابن، ونجح الحذف مباشرة بعد أن أغلقه الأب.
- رقم المقبض لا يعني شيئاً في عملية أخرى: وهذه مفاجأة لم نتوقعها عندما كتبنا التجربة. ففي المحاولة الأولى للكود كان الابن يطبع «المقبض مفتوح» إذا نجحت الدالة
GetHandleInformationفقط، فقال في التجربة الثانية إن المقبض0xB8مفتوح، فظننا أن القائمة لم تعمل. ثم أضفنا فحص المسار، فتبين أن الرقم0xB8في الابن يشير إلى كائن آخر تماماً ليس ملفاً، فتحه الابن لنفسه أثناء بدء التشغيل. والدرس أن رقم المقبض موقع في جدول عملية واحدة، ولا تحكم على شيء في عملية أخرى بالرقم وحده.
والقائمة الصريحة تعمل بالخاصية PROC_THREAD_ATTRIBUTE_HANDLE_LIST التي أضيفت في Windows Vista، وتمرر عبر النسخة الموسعة STARTUPINFOEXW مع الراية EXTENDED_STARTUPINFO_PRESENT، وهذا الجزء من الكود الذي يبنيها:
SIZE_T sz = 0; InitializeProcThreadAttributeList(NULL, 1, 0, &sz);
list = HeapAlloc(GetProcessHeap(), 0, sz); InitializeProcThreadAttributeList(list, 1, 0, &sz);
UpdateProcThreadAttribute(list, 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &wr, sizeof wr, NULL, NULL);
// ... CreateProcessW(..., TRUE, EXTENDED_STARTUPINFO_PRESENT, ..., &si.StartupInfo, &pi)
DeleteProcThreadAttributeList(list);وقد كتب Raymond Chen مقالاً كاملاً عن هذه الطريقة بعنوان Programmatically controlling which handles are inherited by new processes in Win32، وشرح فيه لماذا لا تكفي الطريقة القديمة، أي أن تجعل كل مقبض غير قابل للتوريث ثم تفعل التوريث للحظة قبل CreateProcessW. والسبب أن برنامجك قد يكون فيه خيط آخر يشغل برنامجاً آخر في اللحظة نفسها، فيرث مقبضك الذي فعلت توريثه لابنك أنت. والقائمة الصريحة تحل هذا لأنها تخص استدعاء واحداً فقط، ولاحظ أن المقابض في القائمة يجب أن تكون قابلة للتوريث أصلاً، فالقائمة تحدد أيها يورث، ولا تجعل غير القابل قابلاً. وتجد التفاصيل في صفحة UpdateProcThreadAttribute.

الخيوط Threads: CreateThread وعداد واحد
إذا كانت العملية الجديدة تعطيك عزلاً كاملاً بثمن مرتفع، فالخيط Thread يعطيك تنفيذاً متوازياً بثمن رخيص، ولكن دون أي عزل: كل خيوط العملية ترى المتغيرات نفسها. والدالة CreateThread تأخذ عنوان دالة تبدأ منها الخيط ومعاملاً واحداً تمرره لها، وتعيد مقبضاً للخيط ورقماً له. وفي البرنامج threads.c ننشئ أربعة خيوط، كل منها يزيد عداداً مشتركاً مليون مرة، ثم ينتظر الخيط الأول خروجها كلها بالدالة WaitForMultipleObjects. ونجرب ذلك ثلاث مرات بثلاث طرق للزيادة:
static DWORD WINAPI work(LPVOID p) {
for (int i = 0; i < STEPS; i++) {
if (how == 0) counter++;
else if (how == 1) InterlockedIncrement(&counter);
else { EnterCriticalSection(&cs); counter++; LeaveCriticalSection(&cs); }
}
return (DWORD)(ULONG_PTR)p; // each thread returns its number as its exit code
}
...
for (int t = 0; t < THREADS; t++) h[t] = CreateThread(NULL, 0, work, (LPVOID)(ULONG_PTR)(t + 1), 0, &id[t]);
DWORD w = WaitForMultipleObjects(THREADS, h, TRUE, 30000);والنتيجة يجب أن تكون 4,000,000 في كل مرة، وهذا ما خرج فعلاً:
expected total: 4000000
plain counter++ run 1: total 1693362, lost 2306638, 5.1 ms, wait=0, thread ids 39296 27284 11504 12424, exit codes 1 2 3 4
plain counter++ run 2: total 1717093, lost 2282907, 5.2 ms, wait=0, thread ids 46640 42616 41576 45576, exit codes 1 2 3 4
plain counter++ run 3: total 1535401, lost 2464599, 4.9 ms, wait=0, thread ids 42224 29264 22576 24664, exit codes 1 2 3 4
InterlockedIncrement run 1: total 4000000, lost 0, 84.4 ms, wait=0, thread ids 30232 36440 39684 8984, exit codes 1 2 3 4
InterlockedIncrement run 2: total 4000000, lost 0, 79.7 ms, wait=0, thread ids 28184 14688 45312 8980, exit codes 1 2 3 4
InterlockedIncrement run 3: total 4000000, lost 0, 68.2 ms, wait=0, thread ids 30276 34680 13340 37392, exit codes 1 2 3 4
CRITICAL_SECTION run 1: total 4000000, lost 0, 391.4 ms, wait=0, thread ids 43164 30088 40808 33536, exit codes 1 2 3 4
CRITICAL_SECTION run 2: total 4000000, lost 0, 381.1 ms, wait=0, thread ids 17620 44224 43676 27840, exit codes 1 2 3 4
CRITICAL_SECTION run 3: total 4000000, lost 0, 368.8 ms, wait=0, thread ids 35236 31436 31008 44660, exit codes 1 2 3 4وفي المخرج أعلاه لاحظ التالي:
- الزيادة العادية أضاعت أكثر من نصف العمل: بين 2.28 و2.46 مليون زيادة ضاعت في كل مرة، والرقم يتغير من تشغيل لآخر، وهذه علامة حالة السباق Race Condition: النتيجة تعتمد على توقيت الخيوط لا على الكود. والسبب أن
counter++ليست خطوة واحدة في المعالج، وإنما قراءة ثم إضافة ثم كتابة، فإذا قرأ خيطان القيمة 100 في اللحظة نفسها كتب كل منهما 101، وضاعت إحدى الزيادتين. ومع ثمانية معالجات منطقية في هذا الجهاز تعمل الخيوط الأربعة فعلاً في الوقت نفسه، فيتكرر هذا ملايين المرات. - الطريقتان الصحيحتان أعطتا الرقم الصحيح في كل مرة:
InterlockedIncrementتنفذ القراءة والإضافة والكتابة كعملية ذرية Atomic Operation واحدة يضمنها المعالج، والقسم الحرجCRITICAL_SECTIONيسمح لخيط واحد فقط أن يدخل الجزء المحمي في كل لحظة. - ولكن بثمن واضح: الطريقة الخاطئة أخذت 5 ms، و
InterlockedIncrementبين 68 و84 ms، والقسم الحرج بين 369 و391 ms. والسبب أن الخيوط الأربعة تتنافس على متغير واحد، فتتناوب عليه بدل أن تعمل بالتوازي، ويضاف إلى ذلك أن المعالجات تنقل خط الذاكرة Cache Line الذي فيه المتغير بينها في كل زيادة. - رمز خروج كل خيط وصل: كل خيط أعاد رقمه من 1 إلى 4، وقرأه الخيط الأول بالدالة
GetExitCodeThread، تماماً كما قرأنا رمز خروج العملية من قبل.
والحل في الكود الحقيقي ليس أن تضع قفلاً حول كل سطر، وإنما أن تقلل ما تتشاركه الخيوط: يجمع كل خيط في متغيره المحلي، ثم يجمع الخيط الأول نتائج الأربعة بعد أن تنتهي، فلا يوجد تنافس أصلاً. وتشرح صفحة Critical Section Objects الأقفال المتاحة، ومتى تختار القسم الحرج ومتى تحتاج كائن Mutex الذي يعمل بين العمليات. وتذكر أيضاً قاعدة من وثائق Microsoft: إذا كان الكود الذي يعمل في الخيط يستعمل مكتبة C القياسية C Runtime، فالأنسب أن تنشئ الخيط بالدالة _beginthreadex بدل CreateThread، لأن المكتبة تحتاج أن تجهز بيانات خاصة بكل خيط.

فتح الملفات: CreateFileW
الدالة CreateFileW هي الباب الواحد لكل ما يقرأ ويكتب في Windows: الملفات والمجلدات والأنابيب المسماة Named Pipes والمنافذ التسلسلية Serial Ports والأقراص نفسها. واسمها مضلل، فهي تفتح أكثر مما تنشئ، والمعامل الذي يقرر ماذا تفعل هو الخامس، dwCreationDisposition، وله خمس قيم. والبرنامج files.c يجرب أغلبها مع الحالات التي تقابلها كل يوم، ويطبع لكل محاولة النتيجة ورقم الخطأ والرسالة التي تعطيها FormatMessageW:
> files.exe errors
notes.txt (does not exist) OPEN_EXISTING FAILED GetLastError 2 The system cannot find the file specified.
no-such-folder\notes.txt OPEN_EXISTING FAILED GetLastError 3 The system cannot find the path specified.
notes.txt, create it CREATE_NEW handle GetLastError 0 The operation completed successfully.
notes.txt, create it again CREATE_NEW FAILED GetLastError 80 The file exists.
notes.txt, open or create OPEN_ALWAYS handle GetLastError 183 Cannot create a file when that file already exists.
notes.txt, overwrite CREATE_ALWAYS handle GetLastError 183 Cannot create a file when that file already exists.
the lab folder itself OPEN_EXISTING FAILED GetLastError 5 Access is denied.
the lab folder, backup semantics OPEN_EXISTING handle GetLastError 0 The operation completed successfully.
System32\drivers\etc\hosts, write OPEN_EXISTING FAILED GetLastError 5 Access is denied.
System32\drivers\etc\hosts, read OPEN_EXISTING handle GetLastError 0 The operation completed successfully.
name with a colon a:b.txt CREATE_ALWAYS FAILED GetLastError 3 The system cannot find the path specified.وفي المخرج أعلاه لاحظ التالي:
- الرقمان 2 و3 مختلفان: الخطأ 2
ERROR_FILE_NOT_FOUNDيعني أن المجلد موجود والملف غير موجود، والخطأ 3ERROR_PATH_NOT_FOUNDيعني أن مجلداً في الطريق غير موجود. والتفريق بينهما يوفر عليك وقتاً كبيراً في تشخيص Debugging إعدادات النشر، لأن الثاني غالباً خطأ في المسار نفسه لا في الملف. - الخطأ 183 مع مقبض صحيح ليس خطأ: هذه أشهر نقطة تخدع المطورين في هذه الدالة. فمع
OPEN_ALWAYSوCREATE_ALWAYSنجحت الدالة وأعادت مقبضاً، ومع ذلك أعادتGetLastErrorالرقم 183ERROR_ALREADY_EXISTS، ورسالته تقول «لا يمكن إنشاء ملف موجود». وهذه معلومة تخبرك أن الملف كان موجوداً قبل الفتح، لا خطأ. ولذلك القاعدة: افحص أولاً ما أعادته الدالة، فإذا كانINVALID_HANDLE_VALUEفاقرأGetLastError، ولا تقرأها أبداً لتعرف هل نجحت الدالة. CREATE_NEWفشلت في المرة الثانية بالخطأ 80: وهذا ما يجعلها مناسبة لملفات القفل Lock Files، فالإنشاء والفحص يتمان في خطوة واحدة في النواة، فلا يستطيع برنامجان أن ينشئا الملف نفسه في اللحظة نفسها.- فتح مجلد يحتاج راية خاصة: فتح مجلد المختبر نفسه فشل بالخطأ 5
ERROR_ACCESS_DENIED، رغم أن المستخدم يملك المجلد بالكامل، ونجح بمجرد إضافةFILE_FLAG_BACKUP_SEMANTICS، وهذا مذكور في وثائق الدالة. ولو لم تعرف ذلك لقضيت وقتاً تبحث عن مشكلة صلاحيات غير موجودة. - ملف
hostsيقرأ ولا يكتب: المستخدم العادي فتحه للقراءة، وفشلت الكتابة بالخطأ 5، وهذا هو الخطأ الحقيقي للصلاحيات، وهو المتوقع على ملف فيSystem32. - النقطتان في الاسم: الاسم
a:b.txtأعطى الخطأ 3 لا خطأ في الاسم، لأن Windows قرأa:كاسم قرص، والقرص A غير موجود في هذا الجهاز. وتشرح صفحة Naming Files, Paths, and Namespaces الحروف الممنوعة في الأسماء، ولماذا يجب أن تتحقق Validation من أي اسم ملف يأتي من مستخدم قبل أن تمرره.

ReadFile وWriteFile والنص العربي
الدالتان ReadFile وWriteFile لا تعرفان شيئاً عن النصوص، فهما تنقلان بايتات فقط، والترميز Encoding مسؤوليتك أنت. والوضع utf8 في البرنامج يحول جملتين عربيتين إلى UTF-8 بالدالة WideCharToMultiByte، ويكتبهما، ثم يعود إلى بداية الملف بالدالة SetFilePointerEx ويقرأ ما كتبه:
> files.exe utf8
wrote 69 bytes for 40 characters (UTF-8: Arabic letters take 2 bytes each)
GetFileSizeEx 69, ReadFile from offset 0 got 69 bytes, back as text:
تقرير المبيعات
الربع الثالث: 1250 طلباً
ReadFile at the end of the file: returned 1 with 0 bytes (end of file is success with 0 bytes)
the first 28 bytes decoded as Windows-1252 instead: تقرير المبيعاتوفي المخرج أعلاه لاحظ التالي:
- 40 حرفاً أصبحت 69 بايت: كل حرف عربي في UTF-8 بايتان، والمسافات والأرقام والنقطتان وفواصل الأسطر بايت واحد، ولذلك لا تحجز مخزناً بعدد الحروف أبداً، واسأل دالة التحويل نفسها عن الحجم بتمرير صفر في معامل الحجم أولاً.
- نهاية الملف نجاح بصفر بايت: القراءة الثانية عند نهاية الملف أعادت النجاح ومعه صفر بايت، وهذا بخلاف الأنبوب الذي رأيناه يعود بالفشل والخطأ 109. ولذلك يجب أن تفحص الحلقة التي تقرأ ملفاً عدد البايتات، لا قيمة الدالة فقط.
- الترميز الخطأ يعطي نصاً مشوهاً: البايتات نفسها حين قرأناها بالترميز Windows-1252، وهو الترميز الافتراضي لبرامج كثيرة على الأجهزة الإنجليزية، ظهرت كالسلسلة
تقرير. وهذا الشكل بالضبط هو ما تراه عندما يفتح برنامج ملفاً عربياً بترميز خاطئ، وإذا رأيت هذه الحروف في أي نظام فاعرف فوراً أن ملف UTF-8 قرئ بترميز آخر.
وإذا كنت تريد التفصيل في النسخ W وA من الدوال، وصفحات الترميز Code Pages مثل 1256 و65001، فهذا موضوع مقال واجهة Win32 في هذه المرحلة.
القراءة غير المتزامنة Overlapped I/O
الطريقة التي رأيناها حتى الآن متزامنة Synchronous: الخيط الذي يستدعي ReadFile ينتظر حتى تنتهي القراءة. والبديل أن تفتح الملف بالراية FILE_FLAG_OVERLAPPED، وتمرر بنية OVERLAPPED فيها حدث Event، فتعود ReadFile فوراً بالخطأ 997 ERROR_IO_PENDING، ويكمل الخيط عملاً آخر، ثم يعرف أن القراءة انتهت عندما يصبح الحدث في حالة الإشارة Signaled. وتشرح الفكرة صفحة Synchronous and Asynchronous I/O. وجربنا ذلك بقراءة ملف حجمه 64 MB مرتين، مرة بالطريقة العادية التي تسمح بذاكرة التخزين المؤقت للملفات File Cache، ومرة مع FILE_FLAG_NO_BUFFERING التي تطلب القراءة من القرص مباشرة:
> files.exe overlap
overlapped (cache allowed): ReadFile returned 0, GetLastError 997 (ERROR_IO_PENDING), call took 26.89 ms, 0 free loop turns while waiting, 67108864 bytes after 26.9 ms
overlapped + NO_BUFFERING: ReadFile returned 0, GetLastError 997 (ERROR_IO_PENDING), call took 8.13 ms, 84385 free loop turns while waiting, 67108864 bytes after 70.8 msوالنتيجة فيها درس لم يكن في الحسبان: في المرة الأولى أعادت ReadFile الخطأ 997 كما يجب، ولكن بعد أن قضت داخل الاستدعاء نفسه 26.89 ms، أي أن القراءة كلها تقريباً حدثت قبل أن تعود، ولم يجد الخيط وقتاً يعمل فيه شيئاً آخر، والسبب أن الملف كتب قبل لحظات فكان كله في ذاكرة التخزين المؤقت، فنسخه النظام مباشرة. أما مع NO_BUFFERING فعادت الدالة بعد 8 ms، ودار الخيط 84,385 دورة في حلقة فارغة بينما كان القرص يقرأ، وانتهت القراءة بعد 70.8 ms. والخلاصة أن الراية FILE_FLAG_OVERLAPPED تعطيك الإمكانية لا الضمان، فالنظام قد ينفذ الطلب بشكل متزامن إذا كان ذلك أرخص، وكودك يجب أن يتعامل مع الحالتين: أن تعود الدالة بالنجاح فوراً، أو بالخطأ 997.
وفي البرامج الحقيقية لا ينتظر أحد حدثاً لكل قراءة بهذه الطريقة، وإنما تستعمل السيرفرات منافذ إكمال الإدخال والإخراج I/O Completion Ports، التي يقوم عليها كل سيرفر عالي الأداء في Windows، من IIS إلى مكتبة libuv التي يقوم عليها Node.js. وهذا موضوع أعمق من هذا المقال، ويكفي هنا أن تعرف أن الأساس هو الراية نفسها والبنية نفسها.
تسرب المقابض Handle Leak
آخر تجربة في هذا القسم تفتح الملف نفسه عشرة آلاف مرة دون أن تغلقه، وتسأل النظام عن عدد مقابض العملية بالدالة GetProcessHandleCount قبل الفتح وبعده وبعد الإغلاق. والملف هنا مفتوح بوضع مشاركة يسمح بالحذف FILE_SHARE_DELETE، ولذلك نحاول حذفه أيضاً والمقابض ما زالت مفتوحة:
> files.exe leak
handles at start 57, after 10,000 opens 10057, after closing them 57; DeleteFileW while they were open = 1
leak.txt still visible after the last handle closed: noوفي المخرج أعلاه لاحظ التالي:
- كل فتح مقبض جديد: العدد ارتفع من 57 إلى 10,057 بالضبط، ولم يعد Windows استعمال مقبض واحد للملف نفسه، فكل استدعاء لـ
CreateFileWكائن جديد في النواة له ذاكرته. والبرنامج الذي ينسىCloseHandleفي حلقة تعمل كل ثانية يصل إلى مئات الآلاف من المقابض خلال أيام، فتبطئ النواة أو يرفض النظام فتح مقابض جديدة له. - الحذف نجح والملف ما زال مفتوحاً: لأن كل المقابض سمحت بالحذف، فقبل Windows طلب الحذف، ولكنه لم يحذف الملف فعلاً، وإنما علمه بأنه سوف يحذف Delete Pending، ثم اختفى الملف عندما أغلق المقبض الأخير. وهذا السلوك هو ما يجعل الملف أحياناً «موجوداً وغير موجود» في الوقت نفسه، فلا تستطيع فتحه ولا إنشاء ملف جديد بالاسم نفسه حتى يغلق آخر مقبض.
والطريقة العملية لاكتشاف التسرب في برنامج يعمل هي أن تراقب عمود عدد المقابض Handles في مدير المهام أو في Process Explorer مع الوقت: إذا كان يرتفع ولا ينزل فهناك تسرب، ونافذة المقابض في Process Explorer تريك نوع الكائن الذي يتراكم، فإذا كانت آلاف المقابض من نوع File تشير إلى الملف نفسه فقد عرفت أين تبحث في الكود.
أخطاء شائعة Common Mistakes
- تمرير نص ثابت إلى
CreateProcessW: يعمل مع مترجم ويسقط مع آخر بالخطأ0xC0000005كما رأينا، والسبب أن الدالة تكتب في سطر الأوامر مؤقتاً. انسخه دائماً إلى مصفوفة قابلة للكتابة. - مسار فيه مسافة دون علامات تنصيص: قد يشغل Windows ملفاً آخر بصمت، كما شغل
my.exeفي المختبر. ضع المسار بين علامتي تنصيص، أو مرره كاملاً فيlpApplicationName. - الاعتماد على رمز الخروج 259 لمعرفة هل انتهى البرنامج: البرنامج قد يخرج بالرقم نفسه. انتظر بالدالة
WaitForSingleObject، ثم اقرأ الرمز. - نسيان إغلاق طرف الكتابة في الأب: القراءة لا تنتهي أبداً مع أن الابن خرج. أغلق نسختك مباشرة بعد
CreateProcessW. - انتظار الابن قبل قراءة مخرجه: يعمل مع المخرج القصير، ويتجمد مع أي مخرج أكبر من مخزن الأنبوب، وكان 3 KB في المختبر. اقرأ حتى النهاية ثم انتظر.
- التوريث العام
bInheritHandles = TRUEدون قائمة: يرث الابن ملفات وأقفالاً لم تقصدها، فيبقيها مفتوحة بعد أن تغلقها، ويستطيع أن يقرأها. استعملPROC_THREAD_ATTRIBUTE_HANDLE_LIST. - الحكم على مقبض في عملية أخرى برقمه: الرقم نفسه قد يكون كائناً آخر تماماً هناك، كما حدث معنا في المختبر.
- تعديل متغير مشترك من عدة خيوط دون حماية: النتيجة خاطئة وتختلف في كل تشغيل، وقد ضاع أكثر من نصف الزيادات في المختبر. استعمل الدوال الذرية أو قسماً حرجاً، والأفضل أن تقلل ما تتشاركه الخيوط.
- قراءة
GetLastErrorبعد نجاح الدالة: الرقم 183 مع مقبض صحيح معلومة لا خطأ. افحص قيمة الدالة أولاً. - حلقة قراءة تفحص قيمة
ReadFileفقط: نهاية الملف نجاح بصفر بايت، فالحلقة التي تنتظر الفشل لا تنتهي. افحص عدد البايتات. - نسيان
CloseHandle: عشرة آلاف فتح أصبحت عشرة آلاف مقبض في المختبر، وبرنامج يعمل أسابيع بهذا الخطأ ينتهي بنفاد الموارد.
جدول قرار: أي دالة ولأي حالة؟
| ما تريده | الدالة أو الإعداد | انتبه إلى |
|---|---|---|
| تشغيل برنامج والانتظار حتى ينتهي | CreateProcessW ثم WaitForSingleObject ثم GetExitCodeProcess | سطر أوامر قابل للكتابة، ومسار بين علامتي تنصيص، وإغلاق المقبضين |
| قراءة مخرج البرنامج | CreatePipe مع STARTF_USESTDHANDLES | أغلق طرف الكتابة في الأب، واقرأ قبل أن تنتظر، والخطأ 109 هو النهاية |
| إعطاء الابن مقبضاً واحداً فقط | PROC_THREAD_ATTRIBUTE_HANDLE_LIST | المقابض في القائمة يجب أن تكون قابلة للتوريث |
| تشغيل عمل بالتوازي داخل البرنامج | CreateThread أو _beginthreadex مع مكتبة C | كل متغير مشترك يحتاج حماية أو تصميماً لا يتشارك |
| زيادة عداد مشترك | InterlockedIncrement | أسرع من القفل، ولكن ما زال أبطأ كثيراً من عدم المشاركة |
| إنشاء ملف يجب ألا يكتب فوق غيره | CREATE_NEW | الخطأ 80 يعني أن الملف موجود |
| فتح ملف سجل للإضافة | OPEN_ALWAYS مع FILE_APPEND_DATA | الرقم 183 بعد النجاح معلومة |
| فتح مجلد للحصول على مقبض له | FILE_FLAG_BACKUP_SEMANTICS | دونها خطأ 5 مضلل |
| قراءة لا توقف الخيط | FILE_FLAG_OVERLAPPED | قد تنتهي القراءة متزامنة، فتعامل مع الحالتين |
تدريب عملي Practice
- عدل البرنامج
pipe.cبحيث يمرر حجماً للمخزن في المعامل الأخير لـCreatePipe، مثل 65536، ثم شغل الوضعwaitfirstمرة أخرى، وقارن عدد الكيلوبايتات التي يكتبها الابن قبل أن يتوقف. هل تغير الرقم بالقدر الذي طلبته؟ - شغل الوضع
leakوأثناء الثانية والنصف التي ينتظرها الابن افتح نافذة المقابض في Process Explorer على العمليةchild.exe، وابحث عنsecret.txtبين مقابضها. - عدل
threads.cبحيث يجمع كل خيط في متغير محلي ثم يضيف مجموعه إلى العداد المشترك مرة واحدة بالدالةInterlockedAdd، وقارن الزمن بالطرق الثلاث في الجدول.
حذف المختبر Cleanup
السكربت الأخير 99-cleanup.ps1 يحذف مجلد المختبر في %TEMP% بكل ما فيه، وطبع lab folder removed: True. ولم يغير المختبر شيئاً خارج هذا المجلد: لا مفاتيح في السجل، ولا خدمات، ولا برامج مثبتة، والـ Container الذي بنى البرامج حذف نفسه عند انتهائه.
الخلاصة Summary
CreateProcessWتعيد مقبضين ورقمين وتعود قبل أن ينهي الابن عمله، والانتظار وقراءة رمز الخروج وإغلاق المقبضين مسؤوليتك.- سطر الأوامر يجب أن يكون في ذاكرة قابلة للكتابة، والمسار الذي فيه مسافة يجب أن يكون بين علامتي تنصيص، وإلا فقد يشغل Windows برنامجاً آخر بصمت كما حدث في المختبر.
- الأنبوب ينتهي فقط عندما يغلق آخر طرف كتابة، فأغلق نسختك في الأب، واقرأ قبل أن تنتظر، وإلا فقد تتجمد أداتك مع أول مخرج طويل.
- التوريث العام يعطي الابن كل مقبض قابل للتوريث، والقائمة الصريحة تعطيه ما تحدده فقط، ورقم المقبض لا معنى له خارج عمليته.
- الخيوط تتشارك كل شيء، ومتغير مشترك دون حماية أضاع أكثر من نصف الزيادات، والحماية لها ثمن، والأفضل تصميم لا يتشارك.
CreateFileWتقرر بالمعاملdwCreationDispositionماذا تفعل، وGetLastErrorبعد النجاح قد تحمل معلومة لا خطأ، والبايتات لا ترميز لها إلا ما تقرره أنت.
وفي المقال التالي من هذه المرحلة ننتقل إلى المكتبات المشتركة DLL: كيف يجد Windows المكتبة التي يطلبها برنامجك، وماذا يحدث داخل المحمل Loader قبل أن يبدأ main، ولماذا عرف هذا الجزء من Windows لسنوات باسم جحيم المكتبات DLL Hell.
سجل التحديثات Changelog
- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) بـ Windows PowerShell 5.1 وصلاحيات مستخدم عادي، مع برامج الاختبار مبنية بـ MinGW-w64 GCC 14.2.0 في Container من alpine:3.22.