ผ่านหลายไฟล์ผ่าน stdin (ผ่าน ssh)

ฉันมีโปรแกรมบนรีโมตโฮสต์ซึ่งมีการดำเนินการที่ฉันต้องทำให้เป็นอัตโนมัติ คำสั่งรันโปรแกรมนั้นบนเครื่องเดียวกันจะมีลักษณะดังนี้:

/path/to/program -a file1.txt -b file2.txt

ในกรณีนี้file1.txtและfile2.txtใช้สำหรับสิ่งต่าง ๆ ทั้งหมดภายในโปรแกรมดังนั้นฉันจึงไม่สามารถcatรวมเข้าด้วยกันได้ อย่างไรก็ตามในกรณีของฉันfile1.txtและfile2.txtฉันต้องการส่งผ่านเข้าไปในโปรแกรมนั้นมีอยู่ในอุปกรณ์ของฉันเท่านั้นไม่ใช่บนโฮสต์ที่ฉันต้องใช้งานโปรแกรม ฉันรู้ว่าฉันสามารถฟีดอย่างน้อยหนึ่งไฟล์ผ่าน SSH โดยผ่านมันstdin:

cat file1.txt | ssh host.name /path/to/program -a /dev/stdin -b file2.txt

แต่เนื่องจากฉันไม่ได้รับอนุญาตให้จัดเก็บไฟล์บนโฮสต์ฉันจึงต้องหาวิธีที่จะไปที่file2.txtนั่นเช่นกัน ฉันคิดว่ามันอาจจะเป็นไปได้ผ่านการละเมิดของตัวแปรสภาพแวดล้อมและการใช้ความคิดสร้างสรรค์ของcatและsedกัน แต่ผมไม่ทราบว่าเครื่องมือที่ดีพอที่จะเข้าใจว่าฉันจะใช้พวกเขาเพื่อให้บรรลุนี้ เป็นไปได้หรือไม่และเป็นอย่างไร

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

{
    echo "cat /dev/fd/3 3<<'EOT' /dev/fd/4 4<<'EOT' /dev/fd/5 5<<'EOT'"
    cat file1
    echo EOT
    cat file2
    echo EOT
    cat file3
    echo EOT
} | ssh user@host sh

นี่catคือคำสั่งตัวอย่างซึ่งใช้ชื่อไฟล์เป็นอาร์กิวเมนต์ มันอาจจะแทน:

echo "/path/to/prog -a /dev/fd/3 3<<'EOT' -b /dev/fd/4 4<<'EOT'

แทนที่แต่ละEOTสิ่งที่ไม่เกิดขึ้นในแต่ละไฟล์ตามลำดับ

อาจไม่ใช่สิ่งที่คุณต้องการ ... แต่อาจลองส่งทาร์บอลผ่านท่อที่เปิดโดย ssh

คุณพูดว่า:

ฉันไม่ได้รับอนุญาตให้จัดเก็บไฟล์บนโฮสต์

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

โปรแกรมหลายโปรแกรม (และแม้กระทั่งรูทีน libc) จำเป็นต้องมีการเขียนได้/tmpดังนั้นจึงมีความเป็นไปได้มากที่คุณจะสามารถใช้งานได้

จากนั้นคุณสามารถใช้สคริปต์ที่จะแตก tarball ลงในไดเรกทอรีชั่วคราวเรียกใช้โปรแกรมของคุณและล้างข้อมูลผ่านการเชื่อมต่อ ssh

สิ่งที่ต้องการ:

$ tar cf - file1.txt file2.txt |
  ssh host.name '
      set -e
      tmpdir=$(mktemp -d -t tmp.XXXXXXXXXX)
      cleanup () { rm -rf "$tmpdir"; }
      trap cleanup EXIT
      cd "$tmpdir"
      tar xf -
      /path/to/program -a file1.txt -b file2.txt
  '

สิ่งนี้อาจต้องใช้ความระมัดระวังเป็นพิเศษกับพา ธ ไฟล์และมีบางกรณีที่ต้องพิจารณา (ทดสอบสำหรับไฟล์) แต่วิธีการทั่วไปควรใช้งานได้

หากไม่มีไดเร็กทอรีที่สามารถเขียนได้วิธีที่เป็นไปได้คือการแก้ไขprogramเพื่อใช้ tarball เป็นอินพุตเดี่ยวและคลายเนื้อหาลงในหน่วยความจำ ตัวอย่างเช่นถ้าprogramเป็นสคริปต์ Python การใช้tarfileโมดูลในตัวจะทำให้สำเร็จได้อย่างง่ายดาย

หากคุณสามารถตั้งค่าฟัง TCP (อาจจะเป็นพอร์ตที่สูงขึ้น) แล้วคุณสามารถใช้เซสชั่น SSH ncที่สองที่จะสร้างแหล่งสัญญาณที่สองกับ

ตัวอย่าง:

มีสคริปต์นี้บนเซิร์ฟเวอร์ ( ~/script.bash):

#!/usr/bin/env bash
cat "$1" | tr a 1
nc localhost "$2" | tr '[:lower:]' '[:upper:]'

และมีไฟล์ทั้งสองนี้อยู่ภายในเครื่อง:

$ cat a 
aaa
aaa
aaa
$ cat b
bbb
bbb
bbb

ตอนนี้ก่อนเริ่มต้นแหล่งที่สอง ( $servเป็นเซิร์ฟเวอร์):

ssh "$serv" nc -l -p 2222 -q1 <b &

และเรียกใช้คำสั่งที่เหมาะสม:

$ ssh "$serv" ./script.bash - 2222 <a
111
111
111
BBB
BBB
BBB
[1]+  Done                    ssh "$serv" nc -l -p 2222 -q1 < b

ก่อตั้งขึ้นในความคิดเห็นที่/tmpเขียนได้ดังนั้นเพียงคัดลอกไฟล์ใดไฟล์หนึ่งไว้ล่วงหน้า:

scp -p file2.txt host.name:/tmp/
ssh host.name "/path/to/program -a /dev/stdin -b /tmp/file2.txt && rm /tmp/file2.txt" < file1.txt

ซึ่งจะเป็นการล้างไฟล์ที่คัดลอกหลังจากการเรียกใช้สำเร็จ (เปลี่ยน&&เป็น;ถ้าคุณต้องการลบโดยไม่คำนึงถึงความสำเร็จ แต่โปรดทราบว่าคุณจะสูญเสียมูลค่าการออก)

หากไม่เป็นที่ยอมรับฉันจะเสนอ tinkering with /path/to/programหรือ wrapper ซึ่งสามารถแยกสองไฟล์ออกจากอินพุตสตรีมเดียวเช่น:

awk 'FNR == 1 && NR > 1 { printf "%c%c%c", 28, 28, 28 } 1' file1.txt file2.txt \
  | ssh host.name /path/to/tweaked_program

สิ่งนี้ใช้ตัวคั่นข้อมูล ASCII สี่ (ตัวคั่นไฟล์, FS) และมีสามเท่าเพื่อให้เราลดโอกาสของไฟล์ไบนารีที่มีสตริงนั้นโดยบังเอิญ คุณtweaked_programจะแบ่งอินพุตที่ได้รับจากตัวแยกและดำเนินการกับไฟล์ที่บันทึกสองไฟล์เป็นตัวแปร

แน่นอนว่าถ้าคุณใช้ภาษาที่มีห้องสมุดเพื่อจัดการกับ tarball วิธีที่ปลอดภัยกว่าและสะอาดกว่าก็คือการtarใส่รหัสเข้าไปในโค้ดsshเช่นนี้:

tar -zpc file1.txt file2.txt |ssh host.name /path/to/tweaked_program

และคุณtweaked_programจะขยายและเปิดไฟล์เก็บถาวรบันทึกแต่ละไฟล์เป็นตัวแปรที่แตกต่างกันแล้วเรียกใช้programตรรกะดั้งเดิมของตัวแปรเหล่านั้น

หากคุณได้รับอนุญาตให้ส่งต่อพอร์ตผ่านsshและคุณสามารถเข้าถึงwgetบนเครื่องระยะไกลและไปยังbusyboxเครื่องท้องถิ่นคุณสามารถทำสิ่งต่าง ๆ เช่น:

mkdir /tmp/test; cd /tmp/test
echo 1st_file > 1st_file
echo 2nd_file > 2nd_file

busybox httpd -f -p 127.0.0.1:11080 &
ssh USER@HOST -R 10080:127.0.0.1:11080 '
        cat <(wget -q -O- http://localhost:10080/1st_file) \
            <(wget -q -O- http://localhost:10080/2nd_file)
'
kill $!

(ใช้catเป็นโปรแกรมตัวอย่างที่รับอาร์กิวเมนต์สองไฟล์)

ความสามารถในการส่งต่อพอร์ตผ่าน-Rเป็นสิ่งจำเป็นเท่านั้นแทนที่จะใช้ http คุณสามารถใช้วิธีอื่นเช่น หากการnetcatสนับสนุนของคุณ -dและ-Nตัวเลือก:

nc -Nl localhost 11001 < 1st_file &
nc -Nl localhost 11002 < 2nd_file &
ssh USER@HOST -R 10001:localhost:11001 -R 10002:localhost:11002 '
        cat <(nc -d localhost 10001) <(nc -d localhost 10002)

อาจมีวิธีการแทนที่การแทนที่<(...)กระบวนการหากเชลล์ล็อกอินบนเครื่องรีโมตไม่ใช่ ksh- หรือ bash- like

ทั้งหมดนี้ไม่ดีเกินไป - ความรู้ที่ดีขึ้นเกี่ยวกับระบบ / shells / config / การอนุญาตที่แน่นอน

UPDATE:มันใช้งานไม่ได้จริง ๆ ssh มีความคิดที่ดีมากเกี่ยวกับความหมายของ stdin และ stdout / stderr และไม่อนุญาตให้ใช้ usurping stderr ในการอ่านจากมัน ฉันจะลบคำตอบนี้ในอีกไม่กี่วันเนื่องจากมันไม่ทำงาน ขอบคุณสำหรับการสนทนาที่น่าสนใจมาก !!!

น่าเสียดายที่ไม่มีวิธีที่ดีในการทำเช่นนี้โดยตรงเนื่องจากsshไคลเอนต์จะส่งไฟล์ descriptor สามไฟล์เท่านั้น (stdin , stdoutและstderr) ไปยังเซิร์ฟเวอร์และมันไม่ได้มีบทบัญญัติที่จะผ่านอธิบายไฟล์เพิ่มเติม (ซึ่งจะเป็นประโยชน์สำหรับกรณีการใช้งานนี้โดยเฉพาะ .)

(โปรดทราบว่าโปรโตคอล SSH มีข้อกำหนดให้ส่งผ่านตัวอธิบายไฟล์เพิ่มเติมเท่านั้น sshลูกค้าไม่ได้ใช้วิธีการใช้คุณลักษณะนั้นในทางทฤษฎีการขยายไคลเอ็นต์ด้วยแพตช์จะเพียงพอที่จะเปิดเผยคุณลักษณะนี้)

วิธีแฮ็กหนึ่งเพื่อให้ได้สิ่งที่คุณต้องการคือการใช้ file descriptor 2 ( stderrfile descriptor) เพื่อส่งไฟล์ที่สอง สิ่งที่ต้องการ:

$ ssh remote.name \
      /path/to/program -a /dev/stdin -b /dev/stderr \
      <file1.txt 2<file2.txt

สิ่งนี้ควรใช้งานได้เพียง แต่อาจทำให้เกิดปัญหาหากprogramพยายามเขียนถึง stderr คุณสามารถแก้ไขได้โดยการเล่นกลไฟล์ descriptors อีกครั้งที่ remote remote ก่อนที่คุณจะรันโปรแกรม คุณสามารถย้ายfile2.txtไปที่ file descriptor 3 และเปิด stderr ใหม่เพื่อ mirror stdout:

$ ssh remote.name \
      /path/to/program -a /dev/stdin -b /dev/fd/3 \
      '3<&2' '2>&1' \
      <file1.txt 2<file2.txt