พูดถ้าฉันเขียนโปรแกรมด้วยบรรทัดต่อไปนี้:

int main(int argc, char** argv)

argvตอนนี้ก็รู้ว่าสิ่งที่อาร์กิวเมนต์บรรทัดคำสั่งจะถูกส่งผ่านไปโดยการตรวจสอบเนื้อหาของ

โปรแกรมสามารถตรวจสอบว่ามีช่องว่างระหว่างอาร์กิวเมนต์กี่รายการ? เช่นเมื่อฉันพิมพ์เหล่านี้ในทุบตี:

ibug@linux:~ $ ./myprog aaa bbb
ibug@linux:~ $ ./myprog       aaa      bbb

Environment เป็น Linux ที่ทันสมัย ​​(เช่น Ubuntu 16.04) แต่ฉันคิดว่าคำตอบควรนำไปใช้กับระบบที่สอดคล้องกับ POSIX

ไม่มีความหมายที่จะพูดถึง "ช่องว่างระหว่างข้อโต้แย้ง"; นั่นเป็นแนวคิดของเชลล์

งานของเชลล์คือการรับทั้งบรรทัดของการป้อนข้อมูลและจัดรูปแบบลงในอาร์เรย์ของการขัดแย้งเพื่อเริ่มต้นคำสั่งด้วย สิ่งนี้อาจเกี่ยวข้องกับการแยกสตริงที่ยกมาตัวแปรการขยายไฟล์ไวด์การ์ดและการแสดงออกของตัวหนอนและอื่น ๆ คำสั่งเริ่มต้นด้วยการexecเรียกระบบมาตรฐานซึ่งยอมรับเวกเตอร์ของสตริง

มีวิธีอื่นในการสร้างเวกเตอร์ของสตริง หลายโปรแกรมแยกและทำกระบวนการย่อยของตัวเองด้วยการร้องขอคำสั่งที่กำหนดไว้ล่วงหน้าซึ่งในกรณีนี้ไม่เคยมีสิ่งใดที่เรียกว่า "บรรทัดคำสั่ง" ในทำนองเดียวกันเชลล์กราฟิก (เดสก์ท็อป) อาจเริ่มต้นกระบวนการเมื่อผู้ใช้ลากไอคอนไฟล์และวางลงบนวิดเจ็ตคำสั่ง - อีกครั้งไม่มีบรรทัดข้อความที่จะมีตัวอักษร "ระหว่าง" อาร์กิวเมนต์

เท่าที่คำสั่งถูกเรียกเกี่ยวข้องสิ่งที่เกิดขึ้นในเชลล์หรือกระบวนการ parent / precursor อื่น ๆ เป็นแบบส่วนตัวและซ่อนอยู่ - เราเห็นเฉพาะอาร์เรย์ของสตริงที่ C มาตรฐานระบุว่าmain()สามารถยอมรับได้

โดยทั่วไปไม่มี การแยกวิเคราะห์บรรทัดคำสั่งทำโดยเชลล์ซึ่งไม่ทำให้บรรทัดที่ไม่ถูกวิเคราะห์พร้อมใช้งานสำหรับโปรแกรมที่เรียกใช้ ในความเป็นจริงโปรแกรมของคุณอาจถูกเรียกใช้จากโปรแกรมอื่นซึ่งสร้าง argv ไม่ใช่โดยการแยกสตริง แต่สร้างอาร์เรย์ของอาร์กิวเมนต์โดยทางโปรแกรม

ไม่เป็นไปไม่ได้ยกเว้นว่าช่องว่างเป็นส่วนหนึ่งของการโต้แย้ง

คำสั่งเข้าถึงอาร์กิวเมนต์แต่ละตัวจากอาเรย์ (ในรูปแบบเดียวหรืออื่นขึ้นอยู่กับภาษาการเขียนโปรแกรม) และบรรทัดคำสั่งที่เกิดขึ้นจริงอาจถูกบันทึกลงในไฟล์ประวัติ (ถ้าพิมพ์ที่พรอมต์แบบโต้ตอบในเปลือกที่มีไฟล์ประวัติ) ไม่เคยส่งต่อไปยังคำสั่งในรูปแบบใด ๆ

คำสั่งทั้งหมดบน Unix นั้นอยู่ในขั้นตอนสุดท้ายที่ดำเนินการโดยหนึ่งในexec()ตระกูลของฟังก์ชัน สิ่งเหล่านี้ใช้ชื่อคำสั่งและรายการหรืออาร์เรย์ของอาร์กิวเมนต์ ไม่มีใครรับบรรทัดคำสั่งดังที่พิมพ์ที่ shell prompt system()ฟังก์ชั่นไม่ แต่อาร์กิวเมนต์สตริงจะถูกดำเนินการในภายหลังโดยexecve()ที่อีกครั้งใช้เวลาอาร์เรย์ของการขัดแย้งมากกว่าสตริงบรรทัดคำสั่ง

โดยทั่วไปแล้วเป็นไปไม่ได้เช่นเดียวกับคำตอบอื่น ๆ ที่อธิบายไว้

อย่างไรก็ตามUnix shellsเป็นโปรแกรมทั่วไป (และพวกมันกำลังตีความบรรทัดคำสั่งและทำให้กลมกลืน , นั่นคือการขยายคำสั่งก่อนที่จะทำfork& execveเพื่อมัน) เห็นนี้คำอธิบายเกี่ยวกับbashการดำเนินงานของเปลือก คุณสามารถเขียนเชลล์ของคุณเอง (หรือคุณสามารถแก้ไขเชลล์ซอฟต์แวร์ฟรีที่มีอยู่บางตัวเช่นGNU ทุบตี ) และใช้เป็นเชลล์ (หรือแม้แต่ล็อกอินเชลล์ของคุณดูpasswd (5) & shells (5) )

ตัวอย่างเช่นคุณอาจมีโปรแกรมเชลล์ของคุณเองใส่บรรทัดคำสั่งแบบเต็มในตัวแปรสภาพแวดล้อมบางตัว (ลองจินตนาการMY_COMMAND_LINE) - หรือใช้การสื่อสารระหว่างกระบวนการในรูปแบบอื่น ๆเพื่อส่งบรรทัดคำสั่งจากเชลล์ไปยังกระบวนการลูก

ฉันไม่เข้าใจว่าทำไมคุณถึงต้องการทำเช่นนั้น แต่คุณอาจใช้รหัสเชลล์ในลักษณะนี้ (แต่ฉันแนะนำไม่ให้ทำ)

BTW โปรแกรมอาจเริ่มโดยบางโปรแกรมที่ไม่ใช่เชลล์ (แต่ใช้fork (2)จากนั้นเรียกใช้งาน(2)หรือexecve (2)หรือเพียงexecveเพื่อเริ่มโปรแกรมในกระบวนการปัจจุบัน) ในกรณีที่ไม่มีบรรทัดคำสั่งเลยและโปรแกรมของคุณอาจเริ่มทำงานโดยไม่มีคำสั่ง ...

โปรดสังเกตว่าคุณอาจมีระบบลีนุกซ์ (พิเศษ) บางระบบโดยไม่ติดตั้งเชลล์ใด ๆ นี่มันแปลกและผิดปกติ แต่เป็นไปได้ จากนั้นคุณจะต้องเขียนโปรแกรมinitพิเศษเพื่อเริ่มโปรแกรมอื่น ๆ ตามที่ต้องการโดยไม่ต้องใช้เชลล์ใด ๆ แต่ต้องทำการfork& execveเรียกระบบ

อ่านเพิ่มเติมระบบปฏิบัติการ: สามชิ้นง่าย ๆและอย่าลืมว่าในexecveทางปฏิบัติแล้วการเรียกของระบบ (บนลีนุกซ์พวกมันจะอยู่ในsyscalls (2) , ดูที่บทนำ (2) ) ซึ่งเริ่มต้นพื้นที่แอดเดรสเสมือนใหม่อีกครั้ง สิ่งต่าง ๆ ) ของกระบวนการที่ทำ

คุณสามารถบอกเชลล์ของคุณให้บอกแอปพลิเคชันว่าเชลล์โค้ดใดบ้างที่นำไปสู่การดำเนินการ ตัวอย่างเช่นด้วยการzshส่งข้อมูลใน$SHELL_CODEตัวแปรสภาพแวดล้อมโดยใช้preexec()hook ( printenvใช้เป็นตัวอย่างคุณจะใช้getenv("SHELL_CODE")ในโปรแกรมของคุณ):

$ preexec() export SHELL_CODE=$1
$ printenv SHELL_CODE
printenv SHELL_CODE
$ printenv  SHELL_CODE
printenv  CODE
$ $(echo printenv SHELL_CODE)
$(echo printenv SHELL_CODE)
$ for i in SHELL_CODE; do printenv "$i"; done
for i in SHELL_CODE; do printenv "$i"; done
$ printenv SHELL_CODE; : other command
printenv SHELL_CODE; : other command
$ f() printenv SHELL_CODE
$ f
f

ทั้งหมดเหล่านั้นจะดำเนินการprintenvเป็น:

execve("/usr/bin/printenv", ["printenv", "SHELL_CODE"], 
       ["PATH=...", ..., "SHELL_CODE=..."]);

อนุญาตให้printenvเรียกคืนรหัส zsh ที่นำไปสู่การดำเนินการprintenvกับอาร์กิวเมนต์เหล่านั้น สิ่งที่คุณต้องการจะทำกับข้อมูลนั้นไม่ชัดเจนสำหรับฉัน

ด้วยbashคุณลักษณะที่ใกล้เคียงกับzsh's preexec()จะใช้มัน$BASH_COMMANDในDEBUGกับดัก แต่ทราบว่าbashจะระดับของการเขียนใหม่ในการที่ (และใน refactors เฉพาะบางส่วนของช่องว่างที่ใช้เป็นตัวคั่น) และที่นำไปใช้กับทุกคน (ดีพอใช้) บางคำสั่ง ทำงานไม่ใช่บรรทัดคำสั่งทั้งหมดตามที่ป้อนที่พรอมต์ (ดูเพิ่มเติมที่functraceตัวเลือก)

$ trap 'export SHELL_CODE="$BASH_COMMAND"' DEBUG
$ printenv SHELL_CODE
printenv SHELL_CODE
$ printenv $(echo 'SHELL_CODE')
printenv $(echo 'SHELL_CODE')
$ for i in SHELL_CODE; do printenv "$i"; done; : other command
printenv "$i"
$ printf '%s\n' "$(printenv "SHELL_CODE")"
printf '%s\n' "$(printenv "SHELL_CODE")"
$ set -o functrace
$ printf '%s\n' "$(printenv "SHELL_CODE")"
printenv "SHELL_CODE"
$ print${-+env  }    $(echo     'SHELL_CODE')
print${-+env  } $(echo     'SHELL_CODE')

ดูว่าช่องว่างบางส่วนที่เป็นตัวคั่นในไวยากรณ์ภาษาของเชลล์ถูกบีบอัดเป็น 1 และวิธีที่บรรทัดคำสั่งเต็มไม่ได้ถูกส่งผ่านไปยังคำสั่งเสมอไป ดังนั้นอาจไม่มีประโยชน์ในกรณีของคุณ

โปรดทราบว่าฉันไม่แนะนำให้ทำสิ่งนี้เนื่องจากคุณอาจรั่วไหลข้อมูลที่ละเอียดอ่อนไปยังทุกคำสั่งเช่นเดียวกับใน:

echo very_secret | wc -c | untrustedcmd

จะรั่วไหลความลับที่ทั้งสองและwcuntrustedcmd

แน่นอนคุณสามารถทำสิ่งนั้นกับภาษาอื่นที่ไม่ใช่เปลือก ตัวอย่างเช่นใน C คุณสามารถใช้มาโครบางตัวที่ส่งออกรหัส C ที่ดำเนินการคำสั่งไปยังสภาพแวดล้อม:

#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#define WRAP(x) (setenv("C_CODE", #x, 1), x)

int main(int argc, char *argv[])
{
  if (!fork()) WRAP(execlp("printenv", "printenv", "C_CODE", NULL));
  wait(NULL);
  if (!fork()) WRAP(0 + execlp("printenv",   "printenv", "C_CODE", NULL));
  wait(NULL);
  if (argc > 1 && !fork()) WRAP(execvp(argv[1], &argv[1]));
  wait(NULL);
  return 0;
}

ตัวอย่าง:

$ ./a.out printenv C_CODE
execlp("printenv", "printenv", "C_CODE", NULL)
0 + execlp("printenv", "printenv", "C_CODE", NULL)
execvp(argv[1], &argv[1])

ดูว่าช่องว่างบางส่วนถูกรวมโดยตัวประมวลผลล่วงหน้า C เช่นในกรณีทุบตี ส่วนใหญ่ถ้าไม่ใช่ทุกภาษาจำนวนเนื้อที่ที่ใช้ในตัวคั่นนั้นไม่ต่างกันดังนั้นจึงไม่น่าแปลกใจที่คอมไพเลอร์ / ล่ามใช้เสรีภาพกับพวกเขาที่นี่

ฉันจะเพิ่มสิ่งที่ขาดหายไปในคำตอบอื่น ๆ

ไม่

ดูคำตอบอื่น ๆ

อาจจะเรียงลำดับของ

ไม่มีสิ่งใดที่สามารถทำได้ในโปรแกรม แต่มีบางอย่างที่สามารถทำได้ในเชลล์เมื่อคุณรันโปรแกรม

คุณต้องใช้เครื่องหมายคำพูด ดังนั้นแทนที่จะ

./myprog      aaa      bbb

คุณต้องทำอย่างใดอย่างหนึ่งเหล่านี้

./myprog "     aaa      bbb"
./myprog '     aaa      bbb'

การทำเช่นนี้จะส่งผ่านอาร์กิวเมนต์เดียวไปยังโปรแกรมด้วยช่องว่างทั้งหมด มีความแตกต่างระหว่างทั้งสองอย่างที่สองคือตัวอักษรสตริงที่ตรงตามที่ปรากฏ (ยกเว้นว่า'จะต้องพิมพ์เป็น\') คนแรกจะตีความตัวละครบางตัว แต่แยกออกเป็นหลายข้อโต้แย้ง ดูการอ้างอิงเปลือกสำหรับข้อมูลเพิ่มเติม ดังนั้นไม่จำเป็นต้องเขียนเชลล์ใหม่อีกครั้งผู้ออกแบบเชลล์ได้คิดไปแล้ว อย่างไรก็ตามเนื่องจากตอนนี้เป็นหนึ่งอาร์กิวเมนต์คุณจะต้องผ่านโปรแกรมภายในเพิ่มเติม

ตัวเลือก 2

ส่งผ่านข้อมูลในทาง stdin นี่เป็นวิธีปกติในการรับข้อมูลจำนวนมากเข้าสู่คำสั่ง เช่น

./myprog << EOF
    aaa      bbb
EOF

หรือ

./myprog
Tell me what you want to tell me:
aaaa bbb
ctrl-d

(ตัวเอียงเป็นผลลัพธ์ของโปรแกรม)