Windows للمسؤولين والمطورين الأدلة التقنية

Win32 للعمليات والملفات: CreateProcess وCreateFile

نشغل برامج أخرى ونقرأ مخرجها ونفتح الملفات بلغة C على Windows 11 بصلاحيات مستخدم عادي، ونرى لماذا تتجمد الأدوات مع الأنابيب ولماذا يبقى الملف مفتوحاً بعد أن تغلقه.

Win32 للعمليات والملفات: CreateProcess وCreateFile

إذا كتبت يوماً أداة صغيرة تشغل أمراً آخر وتقرأ مخرجه، مثل سكربت بناء 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 بمهلة صفر، ثم اقرأ رمز الخروج بعد أن تعرف أنه انتهى.

مخطط يبين البرنامج الأب يستدعي CreateProcessW والنواة تنشئ العملية والخيط ثم تعيد PROCESS_INFORMATION بالأرقام من المختبر
ما يحدث عند استدعاء CreateProcessW، والأرقام من تشغيل المختبر.

لماذا يجب أن يكون سطر الأوامر في ذاكرة قابلة للكتابة؟

لاحظ في الدالة 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 في هذه المرحلة.

مخطط يبين كيف يقرأ Windows سطر أوامر فيه مسافة دون علامات تنصيص فيشغل my.exe بدل child.exe
سطر أوامر دون علامات تنصيص: Windows شغل my.exe لأنه وجده أولاً.

وقد يتساءل البعض: إذا كان اسم الملف دون مسار، مثل 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 يعني أن المجلد موجود والملف غير موجود، والخطأ 3 ERROR_PATH_NOT_FOUND يعني أن مجلداً في الطريق غير موجود. والتفريق بينهما يوفر عليك وقتاً كبيراً في تشخيص Debugging إعدادات النشر، لأن الثاني غالباً خطأ في المسار نفسه لا في الملف.
  • الخطأ 183 مع مقبض صحيح ليس خطأ: هذه أشهر نقطة تخدع المطورين في هذه الدالة. فمع OPEN_ALWAYS وCREATE_ALWAYS نجحت الدالة وأعادت مقبضاً، ومع ذلك أعادت GetLastError الرقم 183 ERROR_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 من أي اسم ملف يأتي من مستخدم قبل أن تمرره.
جدول قيم dwCreationDisposition الخمس وما يحدث مع ملف موجود وغير موجود ورقم GetLastError في كل حالة
قيم الإنشاء الخمس في CreateFileW، ورقم GetLastError الذي ظهر لكل حالة في المختبر.

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

  1. عدل البرنامج pipe.c بحيث يمرر حجماً للمخزن في المعامل الأخير لـ CreatePipe، مثل 65536، ثم شغل الوضع waitfirst مرة أخرى، وقارن عدد الكيلوبايتات التي يكتبها الابن قبل أن يتوقف. هل تغير الرقم بالقدر الذي طلبته؟
  2. شغل الوضع leak وأثناء الثانية والنصف التي ينتظرها الابن افتح نافذة المقابض في Process Explorer على العملية child.exe، وابحث عن secret.txt بين مقابضها.
  3. عدل 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.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.