filan - מקוון בענן

תָכְנִית:

שֵׁם

socat - ממסר רב תכליתי (SOcket CAT)

תַקצִיר

socat [אפשרויות]
socat -V
socat -h[h[h]] | -?[?[?]]
וכו '
פרוקן

תיאור

סוקאט הוא כלי עזר מבוסס שורת פקודה שמקים שני זרמי בתים דו-כיווניים ו
מעביר נתונים ביניהם. כי ניתן לבנות את הנחלים מסט גדול של
סוגים שונים של נתונים ומקורות (ראה סוגי כתובות), ובגלל הרבה כתובות
ניתן להחיל אפשרויות על הזרמים, socat יכול לשמש למטרות רבות ושונות.

וכו ' הוא כלי עזר שמדפיס מידע על מתארי הקבצים הפעילים שלו ל-stdout. זה
נכתב לצורך איתור באגים סוקט, אבל עשוי להיות שימושי גם למטרות אחרות. להשתמש ב
-h אפשרות למצוא מידע נוסף.

פרוקן הוא כלי עזר שמדפיס מידע על פרמטרי תהליך ל-stdout. יש לזה
נכתב כדי להבין טוב יותר כמה מאפייני תהליכי UNIX ולניפוי באגים סוקט,
אבל עשוי להיות שימושי גם למטרות אחרות.

מחזור החיים של א סוקט מופע מורכב בדרך כלל מארבעה שלבים.

ב init שלב, אפשרויות שורת הפקודה מנותחות והרישום מאוחל.

במהלך לפתוח שלב, סוקט פותח את הכתובת הראשונה ולאחר מכן את הכתובת השנייה.
שלבים אלה בדרך כלל חוסמים; לכן, במיוחד עבור סוגי כתובות מורכבות כמו גרביים,
יש להשלים בקשות חיבור או תיבות דו-שיח של אימות לפני השלב הבא
התחיל.

ב להעביר שלב, סוקט צופה בתיאורי הקריאה והכתיבה של שני הזרמים באמצעות
select() , וכן, כאשר נתונים זמינים בצד אחד ו ניתן לכתוב לצד השני,
socat קורא אותו, מבצע המרות של תו חדש במידת הצורך, וכותב את הנתונים
מתאר הקובץ לכתוב של הזרם השני, ואז ממשיך להמתין לעוד נתונים
שני הכיוונים.

כאשר אחד מהזרמים מגיע למעשה ל-EOF, ה סגירה שלב מתחיל. סוקאט העברות
תנאי EOF לזרם השני, כלומר מנסה לכבות רק את זרם הכתיבה שלו,
נותן לו הזדמנות לסיים בחן. לזמן מוגדר סוקט ממשיך להעביר
נתונים בכיוון השני, אבל אז סוגר את כל הערוצים הנותרים ומסתיים.

אפשרויות

סוקאט מספק כמה אפשרויות שורת פקודה שמשנות את התנהגות התוכנית. הֵם
אין שום קשר למה שנקרא אפשרויות כתובת המשמשות כחלקי כתובת
מפרטים.

-V גרסת הדפסה ומידע על תכונה זמינה ל-stdout ולצאת.

-h | -?
הדפס טקסט עזרה לסטדout המתאר אפשרויות שורת פקודה וכתובת זמינה
סוגים, ויציאה.

-הה | - ??
כמו -h, בתוספת רשימה של השמות הקצרים של כל אפשרויות הכתובות הזמינות. כמה
האפשרויות תלויות בפלטפורמה, אז פלט זה מועיל לבדיקת ה
יישום מסוים.

-ההה | - ???
כמו -hh, בתוספת רשימה של כל שמות אפשרויות הכתובות הזמינות.

-d ללא אפשרות זו, נוצרות רק הודעות קטלניות ושגיאה; יישום זה
אפשרות גם מדפיסה הודעות אזהרה. ראה אבחון למידע נוסף.

-d -d מדפיס הודעות קטלניות, שגיאות, אזהרה והודעות.

-d -d -d
מדפיס הודעות קטלניות, שגיאה, אזהרה, הודעה ומידע.

-d -d -d -d
מדפיס הודעות קטלניות, שגיאות, אזהרה, הודעה, מידע וניפוי באגים.

-D רושם מידע על מתארי קבצים לפני תחילת שלב ההעברה.

-לי[ ]
כותב הודעות ל-syslog במקום stderr; חומרה כפי שהוגדר עם אפשרות -d.
עם אופציונלי , ניתן לבחור את סוג ה-syslog, ברירת המחדל היא "דימון".
ייתכן שספריות צד שלישי לא יצייתו לאפשרות זו.

-lf
כותב הודעות ל [שם קובץ] במקום stderr. צד שלישי כלשהו
ספריות, במיוחד libwrap, עשויות שלא לציית לאפשרות זו.

-לס כותב הודעות ל-stderr (זו ברירת המחדל). ייתכן שחלק מהספריות של צד שלישי
לא לציית לאפשרות זו, במיוחד נראה ש-libwrap נכנס רק ל-syslog.

-lp
עוקף את שם התוכנית המודפס בהודעות שגיאה ומשמש לבנייה
שמות משתני סביבה.

-לו מרחיב את חותמת הזמן של הודעות השגיאה לרזולוציית מיקרו-שניות. לא עובד
בעת כניסה ל-syslog.

-lm[ ]
מצב יומן מעורב. במהלך האתחול מודפסות הודעות ל-stderr; מתי סוקט התחלות
לולאת שלב ההעברה או מצב הדמון (כלומר לאחר פתיחת כל הזרמים ולפני כן
התחלת העברת נתונים, או, עם שקעי האזנה עם אפשרות מזלג, לפני ה-
קבל תחילה שיחה), הוא מחליף רישום ל-syslog. עם אופציונלי , ה
ניתן לבחור סוג syslog, ברירת המחדל היא "דימון".

-lh מוסיף שם מארח להודעות יומן. משתמש בערך ממשתנה הסביבה HOSTNAME או
הערך מאוחזר עם uname() אם HOSTNAME לא מוגדר.

-v כותב את הנתונים המועברים לא רק לזרמי היעד שלהם, אלא גם ל-stderr.
פורמט הפלט הוא טקסט עם כמה המרות לקריאות, ועם קידומת
"> " או "< " המציינים כיווני זרימה.

-x כותב את הנתונים המועברים לא רק לזרמי היעד שלהם, אלא גם ל-stderr.
פורמט הפלט הוא הקסדצימלי, עם קידומת "> " או "< " המציינת זרימה
כיוונים. ניתן לשלב עם -v.

-ב
מגדיר את בלוק העברת הנתונים [גודל_t]. הכי הרבה בתים מועברים
לכל צעד. ברירת המחדל היא 8192 בתים.

-s כברירת מחדל, סוקט מסתיים כאשר אירעה שגיאה כדי למנוע את התהליך
פועל כאשר לא ניתן להחיל אפשרות כלשהי. עם אפשרות זו, סוקט הוא מרושל
עם שגיאות ומנסה להמשיך. אפילו עם אפשרות זו, socat תצא ב-
קטלניים, ויבטל ניסיונות חיבור כאשר בדיקות האבטחה נכשלו.

-ט
כאשר ערוץ אחד הגיע ל-EOF, חלק הכתיבה של הערוץ השני נסגר.
לאחר מכן, סוקט מחכה [זמן זמן] שניות לפני סיום. ברירת המחדל היא 0.5
שניות. פסק זמן זה חל רק על כתובות שבהן חלק כתיבה וקריאה יכול להיות
נסגר באופן עצמאי. כאשר במהלך מרווח הזמן קצוב חלק הקריאה נותן EOF,
socat מסתיים מבלי להמתין לפסק הזמן.

-T
פסק זמן מוחלט של חוסר פעילות: כאשר socat כבר בלולאת ההעברה וכלום
קרה עבור [זמן זמן] שניות (לא הגיעו נתונים, ללא הפרעה
התרחש...) ואז זה מסתיים. שימושי עם פרוטוקולים כמו UDP שאינם יכולים
העבר EOF.

-u משתמש במצב חד כיווני. הכתובת הראשונה משמשת רק לקריאה, וה-
כתובת שנייה משמשת רק לכתיבה (דוגמה).

-U משתמש במצב חד-כיווני בכיוון הפוך. הכתובת הראשונה משמשת רק עבור
כתיבה, והכתובת השנייה משמשת רק לקריאה.

-g במהלך ניתוח אפשרויות הכתובות, אל תבדוק אם האפשרות נחשבת שימושית ב
סביבת הכתובת הנתונה. השתמש בו אם אתה רוצה לכפות, למשל, מכשיר של א
אפשרות שקע למכשיר טורי.

-ל
אם lockfile קיים, יוצא עם שגיאה. אם lockfile אינו קיים, יוצר אותו ו
ממשיך, מבטל את הקישור ל-lockfile ביציאה.

-W
אם lockfile קיים, ממתין עד שהוא ייעלם. כאשר קובץ הנעילה אינו קיים,
יוצר אותו וממשיך, מבטל את הקישור ל-lockfile ביציאה.

-4 השתמש בגרסת IP 4 למקרה שהכתובות אינן מפרטות באופן מרומז או מפורש
גרסה; זוהי ברירת המחדל.

-6 השתמש בגרסת IP 6 למקרה שהכתובות אינן מפרטות באופן מרומז או מפורש
גרסה.

כתובת מפרט

עם הארגומנטים של שורת הפקודה של הכתובת, המשתמש נותן סוקט הוראות ואת
מידע הכרחי להקמת זרמי הבתים.

מפרט כתובת מורכב בדרך כלל ממילת מפתח מסוג כתובת, אפס או יותר
פרמטרי כתובת נדרשים מופרדים על ידי ':' ממילת המפתח וזה מזה, וכן
אפס או יותר אפשרויות כתובת מופרדות על ידי ','.

מילת המפתח מציינת את סוג הכתובת (למשל, TCP4, OPEN, EXEC). עבור כמה מילות מפתח שם
קיימות מילים נרדפות ('-' עבור STDIO, TCP עבור TCP4). מילות מפתח אינן תלויות רישיות. לכמה
סוגי כתובות מיוחדים, ניתן להשמיט את מילת המפתח: מפרטי כתובת המתחילים בא
ההנחה היא שהמספר הוא כתובות FD (מתאר קובץ גולמי); אם נמצא '/' לפני ה-
ההנחה הראשונה ':' או ',', GOPEN (פתוח קובץ גנרי).

המספר והסוג הנדרשים של פרמטרי כתובת תלויים בסוג הכתובת. למשל, TCP4
דורש מפרט שרת (שם או כתובת), ומפרט יציאה (מספר או
שם השירות).

אפשר לתת אפס או יותר אפשרויות כתובת עם כל כתובת. הם משפיעים על הכתובת ב
כמה דרכים. אפשרויות מורכבות ממילת מפתח אופציה או מילת מפתח אופציה וערך,
מופרד על ידי '='. מילות מפתח של אפשרויות אינן תלויות רישיות. לסינון האפשרויות ש
שימושיים עם סוג כתובת, כל אפשרות היא חברה בקבוצת אפשרויות אחת. לכל אחד
סוג כתובת יש קבוצה של קבוצות אפשרויות מותרות. רק אפשרויות השייכות לאחת מהן
ניתן להשתמש בקבוצות כתובות אלו (למעט אפשרות -g).

מפרטי כתובת בעקבות הסכימה לעיל נקראים גם יחיד כתובת
מפרטים. ניתן לשלב שתי כתובות בודדות עם "!!" ליצור א כפול סוג
כתובת לערוץ אחד. כאן, הכתובת הראשונה משמשת את סוקט לקריאת נתונים, ו
הכתובת השנייה לכתיבת נתונים. אין דרך לציין אפשרות רק פעם אחת עבור
מוחל על שתי הכתובות הבודדות.

בדרך כלל, כתובות נפתחות במצב קריאה/כתיבה. כאשר כתובת היא חלק מדואלי
מפרט כתובת, או כאשר משתמשים באפשרות -u או -U, כתובת עשויה לשמש רק עבור
קריאה או כתיבה. בהתחשב בכך זה חשוב עם כמה סוגי כתובות.

עם socat גרסה 1.5.0 ומעלה, הניתוח המילוני מנסה להתמודד עם ציטוטים ו
סוגריים בצורה משמעותית ומאפשרת בריחה של תווים מיוחדים. אם אחד מה
תווים ( { [ ' נמצא, תו הסגירה המתאים - ) } ] ' - נבדק
ל; הם עשויים גם להיות מקוננים. בתוך מבנים אלה, socats תווים מיוחדים ו
מחרוזות:,!! אינם מטופלים במיוחד. אפשר לברוח מכל הדמויות והמחרוזות האלה
עם \ או בתוך ""

כתובת סוגי

סעיף זה מתאר את סוגי הכתובות הזמינים עם מילות המפתח, הפרמטרים והן
סֵמַנטִיקָה.

לִיצוֹר:
נפתח עם creat() ומשתמש במתאר הקובץ לכתיבה. זֶה
סוג כתובת דורש הקשר לכתיבה בלבד, מכיוון שקובץ שנפתח באמצעות creat אינו יכול
להיקרא מתוך.
לא ניתן להחיל דגלים כמו O_LARGEFILE. אם אתה צריך אותם השתמש ב-OPEN עם אפשרויות
ליצור, ליצור.
חייב להיות נתיב קיים או לא קיים חוקי. אם הוא שם
pipe, creat() עשוי לחסום; אם מתייחס לשקע, זו שגיאה.
קבוצות אפשרויות: FD,REG,NAMED
אפשרויות שימושיות: מצב, משתמש, קבוצה, ביטול קישור מוקדם, ביטול קישור מאוחר, הוסף
ראה גם: OPEN, GOPEN

EXEC:
מזלגות תת תהליך שמבסס תקשורת עם תהליך האב שלו ו
מפעיל את התוכנית שצוינה עם execvp() . היא פקודה פשוטה
עם ארגומנטים מופרדים ברווחים בודדים. אם שם התוכנית מכיל '/', ה-
חלק אחרי ה-'/' האחרון נלקח כ-ARGV[0]. אם שם התוכנית הוא קרוב משפחה
נתיב, הסמנטיקה של execvp() למציאת התוכנית דרך $PATH חלה. לאחר
תחילת תוכנית מוצלחת, סוקט כותב נתונים ל-stdin של התהליך וקורא מתוך
ה-stdout שלו באמצעות שקע תחום UNIX שנוצר על ידי socketpair() כברירת מחדל.
(דוגמא)
קבוצות אפשרויות: FD,SOCKET,EXEC,FORK,TERMIOS
אפשרויות שימושיות: נתיב, fdin, fdout, chroot, su, su-d, nofork, pty, stderr, ctty,
setsid, pipes, login, sigint, sigquit
ראה גם: SYSTEM

FD:
משתמש במתאר הקובץ . הוא חייב כבר להתקיים כקובץ UN*X חוקי
מתאר.
קבוצות אפשרויות: FD (TERMIOS,REG,SOCKET)
ראה גם: STDIO, STDIN, STDOUT, STDERR

GOPEN:
(פתוח כללי) סוג כתובת זה מנסה לטפל בכל ערך מערכת קבצים מלבד
ספריות שימושיות. יכול להיות נתיב יחסי או מוחלט. אם זה כבר
קיים, הסוג שלו מסומן. במקרה של שקע תחום UNIX, סוקט מתחבר; אם
החיבור נכשל, סוקט מניח שקע דאטהגרם ומשתמש בקריאות sendto(). אם ה
הכניסה אינה שקע, סוקט פותח אותו תוך החלת הדגל O_APPEND. אם זה לא
קיים, הוא נפתח עם דגל O_CREAT כקובץ רגיל (דוגמה).
קבוצות אפשרויות: FD,REG,SOCKET,NAMED,OPEN
ראה גם: OPEN, CREATE, UNIX-CONNECT

IP-SENDTO: :
פותח שקע IP גולמי. בהתאם למפרט המארח או אפשרות pf, פרוטוקול IP
נעשה שימוש בגרסה 4 או 6. זה משתמש לשלוח מנות אליהם [כתובת ה - IP]
ומקבל מנות מהמארח, מתעלם מחבילות ממארחים אחרים. פרוטוקול 255
משתמש בשקע הגולמי כאשר כותרת ה-IP היא חלק מהנתונים.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6
אפשרויות שימושיות: pf, ttl
ראה גם: IP4-SENDTO, IP6-SENDTO, IP-RECVFROM, IP-RECV, UDP-SENDTO, UNIX-SENDTO

מִמְשָׁק:
מתקשר עם רשת המחוברת על ממשק באמצעות מנות גולמיות כולל
נתונים ברמת הקישור. הוא השם של ממשק הרשת. כרגע בלבד
זמין בלינוקס. קבוצות אפשרויות: FD,SOCKET
אפשרויות שימושיות: pf, סוג
ראה גם: ip-recv

IP4-SENDTO: :
כמו IP-SENDTO, אבל תמיד משתמש ב-IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4

IP6-SENDTO: :
כמו IP-SENDTO, אבל תמיד משתמש ב-IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6

IP-DATAGRAM: :
שולח נתונים יוצאים לכתובת שצוינה שיכולה להיות במיוחד שידור
או כתובת ריבוי שידור. מנות המגיעות לשקע המקומי נבדקות אם הן
כתובות מקור תואמות לאפשרויות RANGE או TCPWRAP. סוג כתובת זה יכול למשל
לשמש להטמעת שידור סימטרי או א-סימטרי או שידור מרובה
תקשורת.
קבוצות אפשרויות: FD, SOCKET, IP4, IP6, RANGE
אפשרויות שימושיות: bind, range, tcpwrap, broadcast, ip-multicast-loop,
ip-multicast-ttl, ip-multicast-if, ip-add-membership, ttl, tos, pf
ראה גם: IP4-DATAGRAM, IP6-DATAGRAM, IP-SENDTO, IP-RECVFROM, IP-RECV, UDP-DATAGRAM

IP4-DATAGRAM: :
כמו IP-DATAGRAM, אבל תמיד משתמש ב-IPv4. (דוגמא)
קבוצות אפשרויות: FD,SOCKET,IP4,RANGE

IP6-DATAGRAM: :
כמו IP-DATAGRAM, אבל תמיד משתמש ב-IPv6. שימו לב ש-IPv6 אינו יודע
שידורים.
קבוצות אפשרויות: FD,SOCKET,IP6,RANGE

IP-RECVFROM:
פותח שקע IP גולמי של . בהתאם לאפשרות pf, פרוטוקול IP גרסה 4
או 6 משמש. הוא מקבל חבילה אחת מעמית לא מוגדר ויכול לשלוח אחת או
חבילות תשובות נוספות לאותו עמית. מצב זה שימושי במיוחד עם מזלג
אפשרות שבה כל חבילה שמגיעה - מעמיתים שרירותיים - מטופלת בפני עצמה
תת תהליך. זה מאפשר התנהגות דומה לשרתים טיפוסיים מבוססי UDP כמו
ntpd או בשם.
שים לב שחבילות התשובות עשויות להילקח כתנועה נכנסת בעת השולח
וכתובת ה-IP של המקלט זהים מכיוון שאין מספר יציאה אל
להבחין בין השקעים.
כתובת זו פועלת היטב עם עמיתים של כתובת IP-SENDTO (ראה לעיל). פרוטוקול 255
משתמש בשקע הגולמי כאשר כותרת ה-IP היא חלק מהנתונים.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,CHILD,RANGE
אפשרויות שימושיות: pf, fork, range, ttl, broadcast
ראה גם: IP4-RECVFROM, IP6-RECVFROM, IP-SENDTO, IP-RECV, UDP-RECVFROM,
UNIX-RECVFROM

IP4-RECVFROM:
כמו IP-RECVFROM, אבל תמיד משתמש ב-IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4,CHILD,RANGE

IP6-RECVFROM:
כמו IP-RECVFROM, אבל תמיד משתמש ב-IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,CHILD,RANGE

IP-RECV:
פותח שקע IP גולמי של . בהתאם לאפשרות pf, פרוטוקול IP גרסה 4
או 6 משמש. הוא מקבל מנות ממספר עמיתים לא מוגדרים וממזג את
נתונים. אין אפשרות לקבל תשובות. זה יכול להיות מטופל, למשל, על ידי socat IP-SENDTO
לפנות לעמיתים. פרוטוקול 255 משתמש בשקע הגולמי שבו כותרת ה-IP היא חלק ממנו
הנתונים.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,RANGE
אפשרויות שימושיות: pf, טווח
ראה גם: IP4-RECV, IP6-RECV, IP-SENDTO, IP-RECVFROM, UDP-RECV, UNIX-RECV

IP4-RECV:
כמו IP-RECV, אבל תמיד משתמש ב-IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4,RANGE

IP6-RECV:
כמו IP-RECV, אבל תמיד משתמש ב-IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,RANGE

לִפְתוֹחַ:
נפתח באמצעות הקריאה למערכת open() (דוגמה). פעולה זו נכשלת
שקעי תחום UNIX.
הערה: סוג כתובת זה שימושי לעתים נדירות במצב דו-כיווני.
קבוצות אפשרויות: FD,REG,NAMED,OPEN
אפשרויות שימושיות: creat, excl, noatime, nofollow, append, rdonly, wronly, lock,
readbytes, התעלם ממנו
ראה גם: CREATE, GOPEN, UNIX-CONNECT

OPENSSL: :
מנסה ליצור חיבור SSL ל [שירות TCP] פועל [כתובת ה - IP]
באמצעות TCP/IP גרסה 4 או 6 בהתאם למפרט הכתובת, רזולוציית השם או
אפשרות pf.
הערה: עד גרסה 1.7.2.4 אישור השרת נבדק רק לגבי תוקף
נגד מאגר אישורי המערכת או cafil או capath, אך לא להתאמה
שם השרת או כתובת ה-IP שלו. מאז גרסה 1.7.3.0 socat בודק את העמית
תעודת התאמה עם פרמטר או הערך של
אפשרות openssl-commonname. סוקאט מנסה להשוות את זה מול התעודות
נושא commonName, ושמות ה-DNS של סיומת האישורים subjectAltName.
תווים כלליים בתעודה נתמכים.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,TCP,OPENSSL,נסה שנית
אפשרויות שימושיות: צופן, שיטה, אימות, קובץ רגיל שם, capath, אישור,
key, compress, bind, pf, connect-timeout, sourceport, נסה שוב
ראה גם: OPENSSL-LISTEN, TCP

OPENSSL-LISTEN:
מאזין ב-tcp [שירות TCP]. גרסת ה-IP היא 4 או זו שצוינה עם
pf. כאשר חיבור מתקבל, כתובת זו מתנהגת כשרת SSL.
הערה: אתה כנראה רוצה להשתמש באפשרות האישור עם כתובת זו.
הערה: תעודת הלקוח נבדקת רק עבור תקפות מול cafile או capath,
אך לא להתאמה עם שם הלקוח או כתובת ה-IP שלו!
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,TCP,LISTEN,OPENSSL,CHILD,RANGE,TRY RESET
אפשרויות שימושיות: pf, cipher, method, verify, commonname cafil, capath, certificate,
key, compress, fork, bind, range, tcpwrap, su, reuseaddr, reuse
ראה גם: OPENSSL, TCP-LISTEN

צינור:
אם כבר קיים, הוא נפתח. אם זה לא קיים, צינור בשם הוא
נוצר ונפתח. החל מגרסה 1.4.3 של socat, הצינור הנקוב מוסר
כאשר הכתובת סגורה (אך ראה אפשרות unlink-close
הערה: כאשר משתמשים בצינור הן לקריאה והן לכתיבה, הוא פועל כשירות הד.
הערה: כאשר משתמשים במקטרת גם לקריאה וגם לכתיבה, וסוקאט מנסה לכתוב
יותר בתים ממה שהצינור יכול לחסום (Linux 2.4: 2048 בתים), socat עשוי לחסום.
שקול להשתמש באפשרות socat, למשל, -b 2048
קבוצות אפשרויות: FD,NAMED,OPEN
אפשרויות שימושיות: rdonly, nonblock, group, user, mode, unlink-early
ראה גם: צינור ללא שם

צינור יוצר צינור ללא שם ומשתמש בו לקריאה וכתיבה. זה עובד כהד,
כי כל מה שנכתב אליו מופיע מיד כנתונים שנקראו.
הערה: כאשר socat מנסה לכתוב יותר בתים ממה שהצינור יכול לעמוד בתור (Linux 2.4: 2048
בתים), socat עשוי לחסום. שקול, למשל, שימוש באפשרות -b 2048
קבוצות אופציות: FD
ראה גם: צינור בשם

פרוקסי: : :
מתחבר לשרת פרוקסי HTTP ביציאה 8080 באמצעות TCP/IP גרסה 4 או 6
בהתאם למפרט כתובת, רזולוציית שם או אפשרות pf, ושולח א
בקשת CONNECT עבור שם מארח:פורט. אם ה-proxy מעניק גישה ומצליח
להתחבר למטרה, העברת נתונים בין socat למטרה יכולה להתחיל. הערה
שהתעבורה לא צריכה להיות HTTP אלא יכולה להיות פרוטוקול שרירותי.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,TCP,HTTP,Retry
אפשרויות שימושיות: proxyport, ignorecr, proxyauth, resolve, crnl, bind,
connect-timeout, mss, sourceport, נסה שוב
ראה גם: SOCKS, TCP

PTY יוצר פסאודו טרמינל (pty) ומשתמש בצד המאסטר שלו. תהליך אחר עשוי
פתחו את צד העבדים של Pty באמצעותו כמו קו טורי או טרמינל. (דוגמא). אם
גם מנגנוני ptmx וגם מנגנוני openpty זמינים, נעשה שימוש ב- ptmx (POSIX).
קבוצות אפשרויות: FD,NAMED,PTY,TERMIOS
אפשרויות שימושיות: קישור, openpty, wait-slave, מצב, משתמש, קבוצה
ראה גם: UNIX-LISTEN, PIPE, EXEC, SYSTEM

קריאת שורה
משתמש בשורות הקריאה וההיסטוריה של GNU ב-stdio כדי לאפשר עריכה ושימוש חוזר בשורות קלט
(דוגמא).
עקב מגבלות רישוי תכונת הקריאה מושבתת בדביאן. לִרְאוֹת
באגים.
אתה יכול להשתמש ב-STDIO במקום זאת.

SCTP-CONNECT: :
יוצר חיבור זרם SCTP לצוין [כתובת IP] ו
[שירות TCP] באמצעות TCP/IP גרסה 4 או 6 בהתאם לכתובת
מפרט, רזולוציית שם או אפשרות pf.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,SCTP,CHILD,נסה שנית
אפשרויות שימושיות: bind, pf, connect-timeout, tos, mtudiscover, sctp-maxseg,
sctp-nodelay, nonblock, sourceport, ניסיון חוזר, readbytes
ראה גם: SCTP4-CONNECT, SCTP6-CONNECT, SCTP-LISTEN, TCP-CONNECT

SCTP4-CONNECT: :
כמו SCTP-CONNECT, אבל תומך רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4,SCTP,CHILD,Try Retry

SCTP6-CONNECT: :
כמו SCTP-CONNECT, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,SCTP,CHILD,Try Retry

SCTP-LISTEN:
מאזין הלאה [שירות TCP] ומקבל חיבור TCP/IP. גרסת ה-IP היא
4 או זה שצוין עם אפשרות כתובת pf, אפשרות socat (-4, -6), או
משתנה סביבה SOCAT_DEFAULT_LISTEN_IP. שימו לב שפתיחת כתובת זו
בדרך כלל חוסם עד שלקוח מתחבר.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP4,IP6,SCTP,Try Retry
אפשרויות שימושיות: crnl, fork, bind, range, tcpwrap, pf, max-children, backlog,
sctp-maxseg, sctp-nodelay, su, reuseaddr, reuse, cool-write
ראה גם: SCTP4-LISTEN, SCTP6-LISTEN, TCP-LISTEN, SCTP-CONNECT

SCTP4-LISTEN:
כמו SCTP-LISTEN, אבל תומך רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP4,SCTP,Try Retry

SCTP6-LISTEN:
כמו SCTP-LISTEN, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP6,SCTP,Try Retry

SOCKET-CONNECT: : :
יוצר שקע זרם באמצעות פרמטרי השקע הראשון והשני נתון ו
SOCK_STREAM (ראה שקע גבר\(2)) ומתחבר לכתובת המרוחקת. השניים
יש לציין את פרמטרי השקע באמצעות מספרי int. התייעץ עם מערכת ההפעלה שלך
תיעוד וכלול קבצים כדי למצוא את הערכים המתאימים. הכתובת מרחוק
חייב להיות ייצוג הנתונים של מבנה sockaddr ללא sa_family ו- (BSD)
רכיבי sa_len.
שימו לב שאתם יכולים - מעבר לאפשרויות של הקבוצות שצוינו - גם להשתמש
אפשרויות של פרוטוקולים ברמה גבוהה יותר כאשר אתה מיישם את אפשרות socat -g.
קבוצות אפשרויות: FD, SOCKET, CHILD, נסה שוב
אפשרויות שימושיות: bind, setsockopt-int, setsockopt-bin, setsockopt-string
ראה גם: TCP, UDP-CONNECT, UNIX-CONNECT, SOCKET-LISTEN, SOCKET-SENDTO

SOCKET-DTAGRAM: : : :
יוצר שקע דאטהגרם באמצעות שלושת הפרמטרים הראשונים של השקע הנתונים (ראה man
socket\(2)) ושולח נתונים יוצאים לכתובת המרוחקת. שלושת השקעים
יש לציין את הפרמטרים באמצעות מספרי int. עיין בתיעוד מערכת ההפעלה שלך ו
כלול קבצים כדי למצוא את הערכים המתאימים. הכתובת המרוחקת חייבת להיות הנתונים
ייצוג של מבנה sockaddr ללא sa_family ו-(BSD) sa_len
רכיבים.
שימו לב שאתם יכולים - מעבר לאפשרויות של הקבוצות שצוינו - גם להשתמש
אפשרויות של פרוטוקולים ברמה גבוהה יותר כאשר אתה מיישם את אפשרות socat -g.
קבוצות אפשרויות: FD,SOCKET,RANGE
אפשרויות שימושיות: bind, range, setsockopt-int, setsockopt-bin, setsockopt-string
ראה גם: UDP-DATAGRAM, IP-DATAGRAM, SOCKET-SENDTO, SOCKET-RECV, SOCKET-RECVFROM

Socket-LISEN: : :
יוצר שקע זרם באמצעות פרמטרי השקע הראשון והשני נתון ו
SOCK_STREAM (ראה שקע גבר\(2)) וממתין לחיבורים נכנסים
כתובת מקומית. יש לציין את שני פרמטרי השקע באמצעות מספרי int.
עיין בתיעוד מערכת ההפעלה שלך וכלול קבצים כדי למצוא את הערכים המתאימים. ה
local-address חייב להיות ייצוג הנתונים של מבנה sockaddr ללא
רכיבי sa_family ו-(BSD) sa_len.
שימו לב שאתם יכולים - מעבר לאפשרויות של הקבוצות שצוינו - גם להשתמש
אפשרויות של פרוטוקולים ברמה גבוהה יותר כאשר אתה מיישם את אפשרות socat -g.
קבוצות אפשרויות: FD,SOCKET,LISTEN,RANGE,CHILD,TRY RESET
אפשרויות שימושיות: setsockopt-int, setsockopt-bin, setsockopt-string
ראה גם: TCP, UDP-CONNECT, UNIX-CONNECT, SOCKET-LISTEN, SOCKET-SENDTO,
SOCKET-SENDTO

SOCKET-RECV: : : :
יוצר שקע באמצעות שלושת פרמטרי השקע הנתונים (ראה שקע man\(2)) ו
קושר אותו אליו . מקבל נתונים המגיעים. שלושת הפרמטרים חייבים
יצוין על ידי מספרי int. עיין בתיעוד מערכת ההפעלה שלך וכלול קבצים ל
למצוא את הערכים המתאימים. הכתובת המקומית חייבת להיות ייצוג הנתונים של א
מבנה sockaddr ללא רכיבי sa_family ו-(BSD) sa_len.
קבוצות אפשרויות: FD,SOCKET,RANGE
אפשרויות שימושיות: טווח, setsockopt-int, setsockopt-bin, setsockopt-string
ראה גם: UDP-RECV, IP-RECV, UNIX-RECV, SOCKET-DATAGRAM, SOCKET-SENDTO,
SOCKET-RECVFROM

SOCKET-RECVFROM: : : :
יוצר שקע באמצעות שלושת פרמטרי השקע הנתונים (ראה שקע man\(2)) ו
קושר אותו אליו . מקבל נתונים המגיעים ושולח תשובות בחזרה ל
שׁוֹלֵחַ. יש לציין את שלושת הפרמטרים הראשונים כמספרי int. לְהִתְיַעֵץ
תיעוד מערכת ההפעלה שלך וכלול קבצים כדי למצוא את הערכים המתאימים. ה
local-address חייב להיות ייצוג הנתונים של מבנה sockaddr ללא
רכיבי sa_family ו-(BSD) sa_len.
קבוצות אפשרויות: FD,SOCKET,CHILD,RANGE
אפשרויות שימושיות: fork, range, setsockopt-int, setsockopt-bin, setsockopt-string
ראה גם: UDP-RECVFROM, IP-RECVFROM, UNIX-RECVFROM, SOCKET-DATAGRAM, SOCKET-SENDTO,
SOCKET-RECV

SOCKET-SENDTO: : : :
יוצר שקע באמצעות שלושת פרמטרי השקע הנתונים (ראה man socket\(2)).
שולח נתונים יוצאים לכתובת הנתונה ומקבל תשובות. השלושה
יש לציין פרמטרים כמספרי int. עיין בתיעוד מערכת ההפעלה שלך ו
כלול קבצים כדי למצוא את הערכים המתאימים. הכתובת המרוחקת חייבת להיות הנתונים
ייצוג של מבנה sockaddr ללא sa_family ו-(BSD) sa_len
רכיבים.
קבוצות אפשרויות: FD,SOCKET
אפשרויות שימושיות: bind, setsockopt-int, setsockopt-bin, setsockopt-string
ראה גם: UDP-SENDTO, IP-SENDTO, UNIX-SENDTO, SOCKET-DATAGRAM, SOCKET-RECV
SOCKET-RECVFROM

SOCKS4: : :
מתחבר דרך [כתובת IP] ל [כתובת IPv4] פועל [TCP
service], באמצעות פרוטוקול גרביים גרסה 4 על פני IP גרסה 4 או 6 בהתאם
מפרט כתובת, החלטת שם או אפשרות pf (דוגמה).
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,TCP,SOCKS4,נסה שוב
אפשרויות שימושיות: socksuser, socksport, sourceport, pf, נסה שוב
ראה גם: SOCKS4A, PROXY, TCP

SOCKS4A: : :
כמו SOCKS4, אבל משתמש בפרוטוקול socks גרסה 4a, ובכך משאיר את רזולוציית שם המארח
לשרת הגרביים.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,TCP,SOCKS4,נסה שוב

STDERR משתמש במתאר קובץ 2.
קבוצות אפשרויות: FD (TERMIOS,REG,SOCKET)
ראה גם: FD

STDIN משתמש במתאר קובץ 0.
קבוצות אפשרויות: FD (TERMIOS,REG,SOCKET)
אפשרויות שימושיות: readbytes
ראה גם: FD

STDIUM משתמש במתאר קובץ 0 לקריאה ו-1 לכתיבה.
קבוצות אפשרויות: FD (TERMIOS,REG,SOCKET)
אפשרויות שימושיות: readbytes
ראה גם: FD

STDOUT משתמש במתאר קובץ 1.
קבוצות אפשרויות: FD (TERMIOS,REG,SOCKET)
ראה גם: FD

מערכת:
מזלגות תת תהליך שמבסס תקשורת עם תהליך האב שלו ו
מפעיל את התוכנית שצוינה עם system() . שים לב ש
[מחרוזת] לא חייבת להכיל ',' או "!!", וייתכן שתווי מטא של מעטפת יהיו חייבים
להיות מוגן. לאחר תחילת התוכנית המוצלחת, סוקט כותב נתונים ל-stdin של ה
תהליך וקורא מהסטדout שלו.
קבוצות אפשרויות: FD,SOCKET,EXEC,FORK,TERMIOS
אפשרויות שימושיות: נתיב, fdin, fdout, chroot, su, su-d, nofork, pty, stderr, ctty,
setsid, pipes, sigint, sigquit
ראה גם: EXEC

TCP: :
מתחבר ל [שירות TCP] פועל [כתובת IP] באמצעות TCP/IP גרסה 4 או 6
בהתאם למפרט כתובת, רזולוציית שם או אפשרות pf.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,TCP,Retry
אפשרויות שימושיות: crnl, bind, pf, connect-timeout, tos, mtudiscover, mss, nodelay,
nonblock, sourceport, rery, readbytes
ראה גם: TCP4, TCP6, TCP-LISTEN, UDP, SCTP-CONNECT, UNIX-CONNECT

TCP4: :
כמו TCP, אבל תומך רק בפרוטוקול IPv4 (דוגמה).
קבוצות אפשרויות: FD,SOCKET,IP4,TCP,RETRY

TCP6: :
כמו TCP, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,TCP,RETRY

TCP-LISTEN:
מאזין הלאה [שירות TCP] ומקבל חיבור TCP/IP. גרסת ה-IP היא
4 או זה שצוין עם אפשרות כתובת pf, אפשרות socat (-4, -6), או
משתנה סביבה SOCAT_DEFAULT_LISTEN_IP. שימו לב שפתיחת כתובת זו
בדרך כלל חוסם עד שלקוח מתחבר.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP4,IP6,TCP,Try Retry
אפשרויות שימושיות: crnl, fork, bind, range, tcpwrap, pf, max-children, backlog, mss,
su, reuseaddr, reuse, cool-write
ראה גם: TCP4-LISTEN, TCP6-LISTEN, UDP-LISTEN, SCTP-LISTEN, UNIX-LISTEN,
OPENSSL-LISTEN, TCP-CONNECT

TCP4-LISTEN:
כמו TCP-LISTEN, אבל תומך רק בפרוטוקול IPv4 (דוגמה).
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP4,TCP,Try Retry

TCP6-LISTEN:
כמו TCP-LISTEN, אבל תומך רק בפרוטוקול IPv6.
אפשרות שימושית נוספת: ipv6only
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP6,TCP,Try Retry

חָבִית גְדוֹלָה[: / ]
יוצר התקן Linux TUN/TAP ובאופן אופציונלי מקצה לו את הכתובת ומסיכת הרשת
נתון על ידי הפרמטרים. ממשק הרשת המתקבל כמעט מוכן לשימוש על ידי
תהליכים אחרים; socat משרת את ה"צד התיל" שלו. כתובת זו דורשת קריאה וכתיבה
גישה למכשיר שיבוט המנהרה, בדרך כלל /dev/net/tun , כמו גם הרשאה
להגדיר כמה ioctl()s. אפשרות אם למעלה is נדרש ל מיד להפעיל מה היא
מִמְשָׁק!
קבוצות אפשרויות: FD,NAMED,OPEN,TUN
אפשרויות שימושיות: iff-up, tun-device, tun-name, tun-type, iff-no-pi
ראה גם: ip-recv

UDP: :
מתחבר ל [שירות UDP] פועל [כתובת IP] באמצעות UDP/IP גרסה 4 או 6
בהתאם למפרט כתובת, רזולוציית שם או אפשרות pf.
שים לב שבגלל מאפייני פרוטוקול UDP, אין חיבור אמיתי
מְבוּסָס; יש לשלוח נתונים כדי "להתחבר" לשרת, וללא סוף קובץ
מצב יכול להיות מועבר.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6
אפשרויות שימושיות: ttl, tos, bind, sourceport, pf
ראה גם: UDP4, UDP6, UDP-LISTEN, TCP, IP

UDP4: :
כמו UDP, אבל תומך רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4

UDP6: :
כמו UDP, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6

UDP-DATAGRAM: :
שולח נתונים יוצאים לכתובת שצוינה שיכולה להיות במיוחד שידור
או כתובת ריבוי שידור. מנות המגיעות לשקע המקומי נבדקות עבור ה
יציאה מרוחקת נכונה ואם כתובות המקור שלהם תואמות לאפשרויות RANGE או TCPWRAP.
סוג כתובת זה יכול לשמש למשל ליישום סימטרי או אסימטרי
תקשורת שידור או ריבוי שידורים.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,RANGE
אפשרויות שימושיות: bind, range, tcpwrap, broadcast, ip-multicast-loop,
ip-multicast-ttl, ip-multicast-if, ip-add-membership, ttl, tos, sourceport, pf
ראה גם: UDP4-DATAGRAM, UDP6-DATAGRAM, UDP-SENDTO, UDP-RECVFROM, UDP-RECV,
UDP-CONNECT, UDP-LISTEN, IP-DATAGRAM

UDP4-DATAGRAM: :
כמו UDP-DATAGRAM, אבל תומך רק בפרוטוקול IPv4 (דוגמה1, דוגמה2).
קבוצות אפשרויות: FD,SOCKET,IP4, RANGE

UDP6-DATAGRAM: :
כמו UDP-DATAGRAM, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,RANGE

UDP-LISTEN:
ממתין לחבילת UDP/IP שתגיע ב- [שירות UDP] ו'מתחבר' בחזרה ל
שׁוֹלֵחַ. גרסת ה-IP המקובלת היא 4 או זו שצוינה עם אפשרות pf. אנא
שים לב שבגלל מאפייני פרוטוקול UDP, לא נוצר חיבור אמיתי; נתונים
צריך להגיע תחילה מהעמית, ולא ניתן להעביר מצב של סוף קובץ.
שימו לב שפתיחת כתובת זו בדרך כלל חוסמת עד שלקוח מתחבר.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP4,IP6
אפשרויות שימושיות: מזלג, כריכה, טווח, pf
ראה גם: UDP, UDP4-LISTEN, UDP6-LISTEN, TCP-LISTEN

UDP4-LISTEN:
כמו UDP-LISTEN, אבל תומכים רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP4

UDP6-LISTEN:
כמו UDP-LISTEN, אבל תומכים רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,LISTEN,CHILD,RANGE,IP6

UDP-SENDTO: :
מתקשר עם שקע העמיתים שצוין, המוגדר על ידי [שירות UDP] פועל
[כתובת IP], באמצעות UDP/IP גרסה 4 או 6 בהתאם לכתובת
מפרט, רזולוציית שם או אפשרות pf. הוא שולח מנות ומקבל
מנות מאותו שקע עמית בלבד. כתובת זו מיישמת למעשה דאטהגרם
לָקוּחַ. זה עובד היטב עם כתובות מסוג socat UDP-RECVFROM ו-UDP-RECV.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6
אפשרויות שימושיות: ttl, tos, bind, sourceport, pf
ראה גם: UDP4-SENDTO, UDP6-SENDTO, UDP-RECVFROM, UDP-RECV, UDP-CONNECT,
UDP-LISTEN, IP-SENDTO

UDP4-SENDTO: :
כמו UDP-SENDTO, אבל תומך רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4

UDP6-SENDTO: :
כמו UDP-SENDTO, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6

UDP-RECVFROM:
יוצר שקע UDP מופעל [שירות UDP] באמצעות UDP/IP גרסה 4 או 6 בהתאם
על אפשרות pf. הוא מקבל חבילה אחת מעמית לא מוגדר ויכול לשלוח אחת או
חבילות תשובות נוספות לאותו עמית. מצב זה שימושי במיוחד עם אפשרות מזלג
כאשר כל חבילה מגיעה - מעמיתים שרירותיים - מטופלת על ידי משנה משלה
תהליך. זה מאפשר התנהגות דומה לשרתים טיפוסיים מבוססי UDP כמו ntpd או
בשם. כתובת זו פועלת היטב עם עמיתים לכתובת socat UDP-SENDTO.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,CHILD,RANGE
אפשרויות שימושיות: fork, ttl, tos, bind, sourceport, pf
ראה גם: UDP4-RECVFROM, UDP6-RECVFROM, UDP-SENDTO, UDP-RECV, UDP-CONNECT,
UDP-LISTEN, IP-RECVFROM, UNIX-RECVFROM

UDP4-RECVFROM:
כמו UDP-RECVFROM, אבל תומך רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4,CHILD,RANGE

UDP6-RECVFROM:
כמו UDP-RECVFROM, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,CHILD,RANGE

UDP-RECV:
יוצר שקע UDP מופעל [שירות UDP] באמצעות UDP/IP גרסה 4 או 6 בהתאם
על אפשרות pf. הוא מקבל מנות ממספר עמיתים לא מוגדרים וממזג את
נתונים. אין אפשרות לקבל תשובות. זה עובד היטב עם, למשל, כתובת UDP-SENDTO של socat
עמיתים; הוא מתנהג בדומה לשרת syslog.
קבוצות אפשרויות: FD,SOCKET,IP4,IP6,RANGE
אפשרויות שימושיות: fork, pf, bind, sourceport, ttl, tos
ראה גם: UDP4-RECV, UDP6-RECV, UDP-SENDTO, UDP-RECVFROM, UDP-CONNECT, UDP-LISTEN,
IP-RECV, UNIX-RECV

UDP4-RECV:
כמו UDP-RECV, אבל תומך רק בפרוטוקול IPv4.
קבוצות אפשרויות: FD,SOCKET,IP4,RANGE

UDP6-RECV:
כמו UDP-RECV, אבל תומך רק בפרוטוקול IPv6.
קבוצות אפשרויות: FD,SOCKET,IP6,RANGE

UNIX-CONNECT:
מתחבר ל בהנחה שזה שקע תחום UNIX. אם לא
קיים, זו שגיאה; אם אינו שקע תחום UNIX, זהו שקע
שְׁגִיאָה; אם הוא שקע תחום UNIX, אבל שום תהליך לא מקשיב, זהו
שגיאה.
קבוצות אפשרויות: FD,SOCKET,NAMED,RETRY,UNIX
) אפשרויות שימושיות: לאגד
ראה גם: UNIX-LISTEN, UNIX-SENDTO, TCP

UNIX-LISTEN:
מאזין הלאה באמצעות שקע זרם תחום UNIX ומקבל חיבור.
אם קיים ואינו שקע, זו שגיאה. אם קיים
והוא שקע תחום UNIX, הקישור לכתובת נכשל (השתמש באפשרות
ביטול קישור מוקדם!). שימו לב שפתיחת כתובת זו בדרך כלל חוסמת עד לקוח
מתחבר. החל מגרסה 1.4.3 של socat, הערך של מערכת הקבצים מוסר
כאשר כתובת זו סגורה (אך ראה אפשרות unlink-close) (דוגמה).
קבוצות אפשרויות: FD,SOCKET,NAMED,LISTEN,CHILD,RETRY,UNIX
אפשרויות שימושיות: מזלג, umask, מצב, משתמש, קבוצה, ביטול קישור מוקדם
ראה גם: UNIX-CONNECT, UNIX-RECVFROM, UNIX-RECV, TCP-LISTEN

UNIX-SENDTO:
מתקשר עם שקע העמית שצוין, המוגדר על ידי [ ] בהנחה שכן
שקע דאטהגרם של תחום UNIX. זה שולח מנות ומקבל ממנו מנות
שקע עמית בלבד. שימו לב שייתכן שיהיה צורך לאגד את השקע המקומי
לכתובת (למשל /tmp/sock1, שאסור להתקיים קודם לכן). סוג כתובת זה
עובד היטב עם כתובות מסוג SOcat UNIX-RECVFROM ו-UNIX-RECV.
קבוצות אפשרויות: FD,SOCKET,NAMED,UNIX
אפשרויות שימושיות: לאגד
ראה גם: UNIX-RECVFROM, UNIX-RECV, UNIX-CONNECT, UDP-SENDTO, IP-SENDTO

UNIX-RECVFROM:
יוצר שקע דאטהגרם של תחום UNIX [ ]. מקבל חבילה אחת ועלול
לשלוח חבילת תשובות אחת או יותר לאותו עמית. מצב זה שימושי במיוחד
עם אפשרות מזלג שבה כל חבילה שמגיעה - מעמיתים שרירותיים - מטופלת על ידי
תת תהליך משלו. כתובת זו פועלת היטב עם עמיתים של כתובות SOcat UNIX-SENDTO.
קבוצות אפשרויות: FD,SOCKET,NAMED,CHILD,UNIX
אפשרויות שימושיות: מזלג
ראה גם: UNIX-SENDTO, UNIX-RECV, UNIX-LISTEN, UDP-RECVFROM, IP-RECVFROM

UNIX-RECV:
יוצר שקע דאטהגרם של תחום UNIX [ ]. מקבל מנות מכמה
עמיתים לא מוגדרים וממזג את הנתונים. אין אפשרות לקבל תשובות. זה יכול להיות, למשל,
פונה על ידי עמיתים לכתובת socat UNIX-SENDTO. הוא מתנהג בדומה ל-syslog
שרת. קבוצות אפשרויות: FD,SOCKET,NAMED,UNIX
ראה גם: UNIX-SENDTO, UNIX-RECVFROM, UNIX-LISTEN, UDP-RECV, IP-RECV

UNIX-CLIENT:
מתקשר עם שקע העמית שצוין, המוגדר על ידי [ ] בהנחה שכן
שקע תחום UNIX. תחילה הוא מנסה להתחבר, ואם זה נכשל, מניח שכן
שקע דאטהגרם, ובכך תומך בשני הסוגים.
קבוצות אפשרויות: FD,SOCKET,NAMED,UNIX
אפשרויות שימושיות: לאגד
ראה גם: UNIX-CONNECT, UNIX-SENDTO, GOPEN

ABSTRACT-CONNECT:

תקציר-האזנה:

תקציר-שלח:

ABSTRACT-RECVFROM:

ABSTRACT-RECV:

תקציר-לקוח:
הכתובות ABSTRACT כמעט זהות לכתובות UNIX הקשורות למעט
שהם לא מתייחסים לשקעים מבוססי מערכת קבצים אלא לתחום UNIX חלופי
מרחב כתובת. כדי לאחסן את זה בארכיון מחרוזות כתובת השקע מופיעות בקידמת "\0"
כְּלַפֵּי פְּנִים. תכונה זו זמינה (רק?) בלינוקס. קבוצות אפשרויות זהות
כמו בכתובות UNIX הקשורות, אלא שכתובות ה-ABSTRACT אינן
חבר בקבוצת NAMED.

כתובת אפשרויות

ניתן ליישם אפשרויות כתובת כדי להתייחס למפרטים להשפיע על התהליך של
פתיחת הכתובות והמאפיינים של ערוצי הנתונים המתקבלים.

מסיבות טכניות לא ניתן להחיל כל אפשרות על כל סוג כתובת; לְמָשָׁל,
החלת אפשרות socket על קובץ רגיל תיכשל. לתפוס את רוב השילובים חסרי התועלת
כבר בשלב הפתוח, הרעיון של אוֹפְּצִיָה קבוצות הוצג. כל אפשרות
שייך לקבוצת אופציות אחת או יותר. ניתן להשתמש באפשרויות רק עם סוגי כתובות ש
תמכו לפחות באחת מקבוצות האפשרויות שלהם (אך ראו אפשרות -g).

לאפשרויות הכתובות יש סוגי נתונים שהערכים שלהם חייבים להתאים אליהם. כל אפשרות כתובת
מורכב רק ממילת מפתח או מילת מפתח ואחריה "=value", כאשר הערך חייב להתאים
סוג האפשרויות. אפשרויות כתובות מסוימות מטפלות בפרמטרים של קריאות מערכת; לְמָשָׁל,
option sync מגדיר את דגל O_SYNC עם הקריאה ()open. אפשרויות אחרות גורמות למערכת או
שיחת ספרייה; למשל, עם האפשרות `ttl=value' setsockopt(fd, SOL_IP, IP_TTL, value,
הקריאה sizeof(int)) מוחלת. אפשרויות אחרות מוגדרות פנימיות סוקט משתנים שבהם נעשה שימוש
במהלך העברת נתונים; למשל, `crnl' גורם להמרות תווים מפורשות. כמה אפשרויות
יש יישומים מורכבים יותר; למשל, su-d (מושהה משנה) שואל משתמש כלשהו ו
מידע קבוצתי, מאחסן אותם ומחיל אותם מאוחר יותר לאחר קריאת chroot() אפשרית.

אם ניתנות מספר אפשרויות לכתובת, הרצף שלהן במפרט הכתובת
אין (כמעט) השפעה על רצף הביצוע/יישום שלהם. במקום זאת, סוקט יש ל
בנוי ב- אוֹפְּצִיָה שלב מודל שמנסה להביא את האפשרויות בסדר שימושי. כמה
אפשרויות קיימות בצורות שונות (למשל, ביטול קישור, ביטול קישור מוקדם, ביטול קישור מאוחר) כדי לשלוט ב
זמן ביצועם.

אם אותה אפשרות צוינה יותר מפעם אחת בתוך מפרט כתובת אחד, עם
ערכים שווים או שונים, ההשפעה תלויה בסוג האופציה. אפשרויות המביאות
קריאות לפונקציות כמו setsockopt() גורמות למספר הפעלות. עם אפשרויות שקובעות
פרמטרים עבור קריאה נדרשת כמו open() או הגדרת דגלים פנימיים, הערך של האחרון
התרחשות אופציה יעילה.

הקיום או הסמנטיקה של אפשרויות רבות תלויות במערכת. סוקאט בדרך כלל לא
נסה לחקות תכונות חסרות של libc או ליבה, זה רק מספק ממשק ל-
המערכת הבסיסית. לכן, אם למערכת הפעלה חסרה תכונה, האפשרות הקשורה היא
פשוט לא זמין בפלטפורמה הזו.

הפסקאות הבאות מציגות רק את אפשרויות הכתובות הנפוצות יותר. לעוד
התייחסות מקיפה ולמצוא מידע על שמות אופציות קנוניים, שמות כינויים,
שלבי אפשרויות, ופלטפורמות לראות את הקובץ xio.help.

FD אוֹפְּצִיָה קבוצה

קבוצת אפשרויות זו מכילה אפשרויות המוחלות על מתאר קובץ בסגנון UN*X, לא
משנה איך זה נוצר. כי הכל עדכני סוקט סוגי הכתובות הם מתאר קבצים
בהתבסס, ניתן להחיל אפשרויות אלה על כל כתובת.
הערה: חלק מהאפשרויות הללו הן גם חברות בקבוצת אפשרויות אחרת, המספקת
מנגנון אחר שאינו מבוסס על FD. עבור אפשרויות אלה, זה תלוי בסוג הכתובת בפועל
וקבוצות האופציות שלו באיזה מנגנון נעשה שימוש. המנגנון השני, שאינו מבוסס FD הוא
בראש סדר העדיפויות.

cloexec=
מגדיר את דגל FD_CLOEXEC עם קריאת המערכת fcntl() לערך . אם מוגדר, ה
מתאר הקובץ נסגר בקריאות פונקציות משפחתיות של exec(). סוקאט מטפל פנימי
הדגל הזה עבור ה-fds שהוא שולט בו, כך שברוב המקרים לא יהיה צורך להחיל
אפשרות זו.

setlk מנסה להגדיר נעילת כתיבה לפי שיקול דעת לכל הקובץ באמצעות ה-fcntl(fd,
F_SETLK, ...) קריאת מערכת. אם הקובץ כבר נעול, שיחה זו מביאה ל-
שְׁגִיאָה. בלינוקס, כאשר הרשאות הקובץ לקבוצה הן "S" (gx,g+s), וה-
מערכת הקבצים מותקנת באופן מקומי עם אפשרות "mand", המנעול הוא חובה, כלומר
מונע מתהליכים אחרים לפתוח את הקובץ.

setlkw מנסה להגדיר נעילת כתיבה ממתינה לקובץ כולו באמצעות ה-
fcntl(fd, F_SETLKW, ...) קריאת מערכת. אם הקובץ כבר נעול, השיחה הזו
בלוקים. ראה אפשרות setlk למידע על הפיכת מנעול זה לחובה.

setlk-rd
מנסה להגדיר נעילת קריאה לפי שיקול דעת לכל הקובץ באמצעות ה-fcntl(fd,
F_SETLK, ...) קריאת מערכת. אם הקובץ כבר כתוב נעול, השיחה הזו תוצא
בשגיאה. ראה אפשרות setlk למידע על הפיכת מנעול זה לחובה.

setlkw-rd
מנסה להגדיר נעילת קריאה ממתינה על פי שיקול דעת לכל הקובץ באמצעות
fcntl(fd, F_SETLKW, ...) קריאת מערכת. אם הקובץ כבר כתוב נעול, זה
חסימות שיחות. ראה אפשרות setlk למידע על הפיכת מנעול זה לחובה.

עדר-אקס
מנסה להגדיר מנעול ייעוץ בלעדי חוסם לקובץ באמצעות ה- flock(fd,
LOCK_EX) קריאת מערכת. סוקאט נתקע בשיחה זו אם הקובץ ננעל על ידי אחר
התהליך.

צאן-לשעבר-נ.ב
מנסה להגדיר מנעול ייעוץ בלעדי לא חוסם לקובץ באמצעות ה- flock(fd,
LOCK_EX|LOCK_NB) קריאת מערכת. אם הקובץ כבר נעול, אפשרות זו מתקבלת
שגיאה.

צאן-ש
מנסה להגדיר מנעול ייעוץ משותף חוסם לקובץ באמצעות ה- flock(fd,
LOCK_SH) קריאת מערכת. סוקאט נתקע בשיחה זו אם הקובץ ננעל על ידי אחר
התהליך.

צאן-ש-נ.ב
מנסה להגדיר מנעול ייעוץ משותף לא חוסם לקובץ באמצעות ה- flock(fd,
LOCK_SH|LOCK_NB) קריאת מערכת. אם הקובץ כבר נעול, אפשרות זו מתקבלת
שגיאה.

לנעול מגדיר נעילת חסימה לקובץ. משתמש במנגנון setlk או flock בהתאם
זמינות בפלטפורמה הספציפית. אם שניהם זמינים, גרסת POSIX
(setlkw) משמש.

משתמש=
מגדיר את (בעלים) של הנחל. אם הכתובת היא חברה ב-NAMED
קבוצת אפשרויות, סוקט משתמש בקריאה למערכת chown() לאחר פתיחת הקובץ או הכריכה
לשקע התחום של UNIX (מצב מירוץ!). ללא הזנת מערכת קבצים, סוקט סטים
המשתמש בזרם באמצעות קריאת המערכת fchown() . שיחות אלו עשויות לדרוש
הרשאות שורש.

משתמש מאוחר=
מגדיר את הבעלים של ה-fd ל עם קריאת המערכת fchown() לאחר פתיחת או
חיבור הערוץ. זה שימושי רק בערכי מערכת קבצים.

קבוצה=
מגדיר את של הנחל. אם הכתובת חברה באפשרות NAMED
קבוצה, סוקט משתמש בקריאת המערכת chown() לאחר פתיחת הקובץ או קשירה ל-
שקע תחום UNIX (מצב מירוץ!). ללא הזנת מערכת קבצים, סוקט מגדיר את
הקבוצה של הזרם עם קריאת המערכת fchown() . שיחות אלו עשויות לדרוש קבוצה
חברות או הרשאת שורש.

קבוצה-מאוחר=
מגדיר את הקבוצה של ה-fd ל עם קריאת המערכת fchown() לאחר פתיחת או
חיבור הערוץ. זה שימושי רק בערכי מערכת קבצים.

מצב=
מגדיר את [mode_t] (הרשאות) של הזרם. אם הכתובת היא חברה ב
קבוצת האפשרויות NAMED ומשתמשת בקריאה open() או creat(), המצב מוחל
עם אלה. אם הכתובת חברה בקבוצת האפשרויות NAMED מבלי להשתמש באלה
שיחות מערכת, סוקט משתמש בקריאת המערכת chmod() לאחר פתיחת הערך של מערכת הקבצים
או כריכה לשקע תחום UNIX (תנאי מירוץ!). אחרת, סוקט מגדיר את
מצב הזרם באמצעות fchmod() . שיחות אלו עשויות לדרוש בעלות או שורש
זכות.

Perm-late=
מגדיר את ההרשאות של ה-fd לערך [mode_t] באמצעות מערכת fchmod().
להתקשר לאחר פתיחת הערוץ או חיבורו. זה שימושי רק במערכת קבצים
ערכים.

append=
תמיד כותב נתונים לסוף הקובץ בפועל. אם הכתובת היא חברה ב-OPEN
קבוצת אפשרויות, סוקט משתמש בדגל O_APPEND עם קריאת המערכת open() (דוגמה).
אחרת, סוקט מחיל את הקריאה fcntl(fd, F_SETFL, O_APPEND).

nonblock=
מנסה לפתוח או להשתמש בקובץ במצב לא חסימה. ההשפעות היחידות שלה הן שה
connect() קריאה של כתובות TCP אינה חוסמת, וכי פתיחת צינור בשם עבור
הקריאה לא חוסמת. אם הכתובת חברה בקבוצת האפשרויות OPEN, סוקט
משתמש בדגל O_NONBLOCK עם קריאת המערכת open() . אחרת, סוקט חל על
קריאה fcntl(fd, F_SETFL, O_NONBLOCK).

בינרי פותח את הקובץ במצב בינארי כדי למנוע המרות מסיימת שורה מרומזת
(סייגווין).

טֶקסט פותח את הקובץ במצב טקסט כדי לאלץ המרות מסיים שורה מרומזים (Cygwin).

ללא ירושה
לא שומר את הקובץ הזה פתוח בתהליך שהולידה (Cygwin).

מגניב-כתוב
לוקח את זה בקלות כאשר הכתיבה נכשלת עם EPIPE או ECONNRESET ומתעד את ההודעה עם
לוח מודעות רמה במקום שגיאה. זה מונע את מילוי קובץ היומן
הודעות שגיאה חסרות תועלת כאשר socat משמש כשרת נפח גבוה או פרוקסי שבו
לקוחות לעתים קרובות מבטלים את החיבור.
אפשרות זו היא ניסיונית.

סוף-סגור
משנה את השיטה (תלויה בכתובת) של סיום חיבור כדי פשוט לסגור את
מתארי קבצים. זה שימושי כאשר יש לעשות שימוש חוזר בחיבור או לשתף אותו
עם תהליכים אחרים (לדוגמה).
בדרך כלל, חיבורי שקע יסתיימו עם כיבוי(2) שמסיים את
שקע גם אם הוא משותף למספר תהליכים. close(2) "מנתק" את השקע
מהתהליך אבל שומר אותו פעיל כל עוד יש קישורים מאחרים
תהליכים.
באופן דומה, כאשר כתובת מסוג EXEC או SYSTEM מסתיימת, socat בדרך כלל
להרוג באופן מפורש את תהליך המשנה. עם אפשרות זו, זה פשוט יסגור את הקובץ
מתארים.

סגור-אין
משנה את השיטה (תלויה בכתובת) של כיבוי חלק הכתיבה של a
חיבור לא לעשות כלום.

לעצום את
משנה את השיטה (תלויה בכתובת) של כיבוי חלק הכתיבה של a
חיבור לכיבוי\(fd, SHUT_WR). שימושי רק עם שקעים.

סגור-סגור
משנה את השיטה (תלויה בכתובת) של כיבוי חלק הכתיבה של a
חיבור לסגור\(fd).

shut-null
כאשר כתובת אחת מציינת EOF, סוקט ישלח חבילה בגודל אפס לכתיבה
ערוץ של הכתובת האחרת כדי להעביר את מצב EOF. זה שימושי עם UDP
ופרוטוקולי נתונים אחרים. נבדק נגד netcat ו- socat עם אופציה
null-eof.

null-eof
בדרך כלל סוקט יתעלם מחבילות ריקות (עומס בגודל אפס) המגיעות ל-datagram
שקעים, כך שהוא שורד סריקות יציאות. עם האפשרות הזו סוקט מפרש ריק
מנות דאטהגרם כמחוון EOF (ראה shut-null).

ioctl-void=
קורא ל-ioctl() עם ערך הבקשה כארגומנט שני ו-NULL כארגומנט שלישי.
אפשרות זו מאפשרת להשתמש ב-ioctls שאינם מיושמים במפורש ב-socat.

ioctl-int= :
קורא ל-ioctl() עם ערך הבקשה כארגומנט שני והערך השלם as
טיעון שלישי.

ioctl-intp= :
קורא ל-ioctl() עם ערך הבקשה כארגומנט שני ומצביע ל-
ערך מספר שלם כארגומנט שלישי.

ioctl-bin= :
קורא ל-ioctl() עם ערך הבקשה כארגומנט שני ומצביע לנתון
ערך נתונים כארגומנט שלישי. יש לציין נתונים אלה ב טופס.

ioctl-string= :
קורא ל-ioctl() עם ערך הבקשה כארגומנט שני ומצביע לנתון
מחרוזת כארגומנט שלישי. טופס.

שמות אוֹפְּצִיָה קבוצה

אפשרויות אלה פועלות על ערכי מערכת קבצים.
ראה גם אפשרויות משתמש, קבוצה ומצב.

משתמש מוקדם=
משנה את (הבעלים) של ערך מערכת הקבצים לפני הגישה אליו, באמצעות ה-
קריאת מערכת chown(). קריאה זו עשויה לדרוש הרשאות שורש.

קבוצה-מוקדמת=
משנה את של ערך מערכת הקבצים לפני הגישה אליו, באמצעות ה-chown()
שיחת מערכת. שיחה זו עשויה לדרוש חברות בקבוצה או הרשאות שורש.

Perm-early=
משנה את [mode_t] של ערך מערכת הקבצים לפני הגישה אליו, באמצעות ה-
קריאת מערכת chmod() קריאה זו עשויה לדרוש בעלות או הרשאות בסיס.

umask=
מגדיר את umask של התהליך ל [mode_t] לפני הגישה למערכת הקבצים
כניסה (שימושי עם שקעי תחום UNIX!). שיחה זו עשויה להשפיע על הכל
פעולות של סוקט תהליך!

ביטול קישור מוקדם
מבטל את הקישור (מסיר) את הקובץ לפני פתיחתו ואפילו לפני החלת משתמש מוקדם
וכו '

הקישור מבטל את הקישור (מסיר) את הקובץ לפני הגישה אליו, אך לאחר תחילת המשתמש וכו'.

ביטול קישור-מאוחר
מבטל את הקישור (מסיר) את הקובץ לאחר פתיחתו כדי להפוך אותו לבלתי נגיש עבור אחרים
תהליכים לאחר מצב מרוץ קצר.

בטל קישור-סגור
מסיר את רשומת מערכת הקבצים של הכתובות בעת סגירת הכתובת. עבור צינורות בעלי שם,
שקעי תחום האזנה של יוניקס, והקישורים הסמליים של כתובות PTY, ברירת המחדל
הוא 1; עבור קבצים שנוצרו, קבצים שנפתחו, קבצים שנפתחו גנריים ותחום יוניקס של הלקוח
שקעים ברירת המחדל היא 0.

לִפְתוֹחַ אוֹפְּצִיָה קבוצה

אפשרויות הקבוצה OPEN מאפשרות להגדיר דגלים עם קריאת המערכת open() . למשל, אפשרות
`creat' מגדיר את דגל O_CREAT.
ראה גם אפשרויות להוסיף וללא חסימה.

ליצור=
יוצר את הקובץ אם הוא לא קיים (דוגמה).

dsync=
חוסם קריאות write() עד שה-metainfo נכתב פיזית למדיה.

excl=
עם אפשרות יצירת, אם קיים קובץ זו שגיאה.

largefile=
במערכות 32 סיביות, מאפשר קובץ גדול מ-2^31 בתים.

Noatime
מגדיר את האפשרויות O_NOATIME, כך שקריאות לא ישנו את חותמת הזמן של הגישה.

נוקטי=
לא הופך את הקובץ הזה למסוף השולט.

nofollow=
אינו עוקב אחר קישורים סמליים.

nshare=
אינו מאפשר לשתף קובץ זה עם תהליכים אחרים.

rshare=
אינו מאפשר לתהליכים אחרים לפתוח קובץ זה לכתיבה.

rsync=
חוסם את הכתיבה() עד שה-metainfo נכתב פיזית למדיה.

סינכרון=
חוסם כתב() עד שהנתונים נכתבים פיזית למדיה.

rdonly=
פותח את הקובץ לקריאה בלבד.

בטעות=
פותח את הקובץ לכתיבה בלבד.

TRUNC חותך את הקובץ לגודל 0 במהלך פתיחתו.

REG ו BLK אוֹפְּצִיָה קבוצה

אפשרויות אלה מיושמות בדרך כלל על מתאר קובץ UN*X, אבל הסמנטיקה שלהם עושה
חוש רק בקובץ התומך בגישה אקראית.

לחפש=
מחיל את ה-lseek(fd, , SEEK_SET) (או lseek64 ) קריאת מערכת, כך
מיקום מצביע הקובץ לחלוטין [off_t או off64_t]. שימו לב
שערך חסר כברירת מחדל הוא 1, לא 0.

seek-cur=
מחיל את ה-lseek(fd, , SEEK_CUR) (או lseek64 ) קריאת מערכת, כך
מיקום מצביע הקובץ [off_t או off64_t] בייטים יחסית לזה שלו
המיקום הנוכחי (שהוא בדרך כלל 0). שים לב שערך חסר מוגדר כברירת מחדל
1, לא 0.

seek-end=
מחיל את ה-lseek(fd, , SEEK_END) (או lseek64 ) קריאת מערכת, כך
מיקום מצביע הקובץ [off_t או off64_t] בתים יחסית ל-
הקצה הנוכחי של קבצים. שים לב שערך חסר הוא 1, לא 0.

ftruncate=
מחיל את ה-ftruncate(fd, ) (או ftruncate64 אם זמין) קריאת מערכת, כך
קיצוץ הקובץ במיקום [off_t או off64_t]. שימו לב כי א
ברירת המחדל של ערך חסר הוא 1, לא 0.

secrm=

unrm=

compr=

ext2-sync=

בלתי ניתן לשינוי=

ext2-append=

nodump=

ext2-noatime=

journal-data=

notail=

dirsync=
אפשרויות אלה משנות תכונות קבצים לא סטנדרטיות במערכות הפעלה ובקבצים
מערכות התומכות בתכונות אלו, כמו לינוקס עם ext2fs, ext3fs או reiserfs.
ראה צ'אטר גבר 1 למידע על אפשרויות אלו. שימו לב שיכול להיות שיש
תנאי מרוץ בין יצירת הקובץ לבין החלת אפשרויות אלו.

תהליך אוֹפְּצִיָה קבוצה

אפשרויות של קבוצה זו משנות את מאפייני התהליך במקום להשפיע רק על נתון אחד
עָרוּץ. עבור כתובות EXEC ו-SYSTEM ועבור כתובות מסוג LISTEN ו-CONNECT עם
אפשרות FORK, אפשרויות אלו חלות על תהליכי הילד במקום על תהליך socat הראשי.

chroot=
מבצע פעולת chroot() ל לאחר עיבוד הכתובת
(דוגמא). קריאה זו עשויה לדרוש הרשאות שורש.

chroot-early=
מבצע פעולת chroot() ל לפני פתיחת הכתובת. השיחה הזו
עשוי לדרוש הרשאת שורש.

setgid=
משנה את הבסיסי של התהליך לאחר עיבוד הכתובת. השיחה הזו
עשוי לדרוש הרשאת שורש. אנא שימו לב כי אפשרות זו אינה נופלת אחרת
הרשאות הקשורות לקבוצה.

setgid-early=
כמו setgit אבל מבוצע לפני פתיחת הכתובת.

setuid=
משנה את (הבעלים) של התהליך לאחר עיבוד הכתובת. השיחה הזו
עשוי לדרוש הרשאת שורש. שימו לב שאופציה זו אינה מורידה את הקבוצה
הרשאות קשורות. בדוק אם האפשרות su מתאימה יותר לצרכים שלך.

setuid-early=
כמו setuid אבל מבוצע לפני פתיחת הכתובת.

su=
משנה את (בעלים) וקבוצות של התהליך לאחר עיבוד הכתובת
(דוגמא). קריאה זו עשויה לדרוש הרשאות שורש.

סו-ד=
שם קצר עבור substuser-delayed. משנה את (בעלים) וקבוצות של
תהליך לאחר עיבוד הכתובת (דוגמה). המשתמש והקבוצות שלו הם
אוחזר לפני chroot() אפשרי. קריאה זו עשויה לדרוש הרשאות שורש.

setpgid=
הופך את התהליך לחבר בקבוצת התהליך שצוינה . אם אין ערך
נתון, או אם הערך הוא 0 או 1, התהליך הופך למנהיג של תהליך חדש
קבוצה.

סטסיד הופך את התהליך למנהיג של מפגש חדש (דוגמה).

קריאת שורה אוֹפְּצִיָה קבוצה

עקב מגבלות רישוי תכונת הקריאה מושבתת בדביאן (ראה באגים).
אפשרויות אלה חלות על סוג כתובת קו הקריאה.

היסטוריה=
קורא וכותב היסטוריה מ/אל (דוגמא).

ללא הנחיה
מאז גרסה 1.4.0, socat בברירת מחדל מנסה לקבוע הנחיה - כלומר אז
הועבר לשיחת ה-readline - על ידי זכירת השורה הלא שלמה האחרונה של
תְפוּקָה. עם אפשרות זו, socat לא מעביר הנחיה ל-readline, אז זה מתחיל
עריכת שורה בעמודה הראשונה של הטרמינל.

noecho=
מציין תבנית רגילה עבור הנחיה המונעת את שורת הקלט הבאה
מהצגה על המסך ומהוספה להיסטוריה. הפקודה
מוגדר כטקסט שהוצא לכתובת readline לאחר הכתובת האחרונה
תו חדש ולפני שהוקלד תו קלט. התבנית היא קבועה
ביטוי, למשל "^[Pp]assword:.*$" או "([Uu]ser:|[Pp]assword:)". ראה ביטוי רגיל\(7)
לפרטים. (דוגמא)

הנחיה=
מעביר את המחרוזת כהנחיה לפונקציית readline. readline מדפיס הודעה זו
כאשר עוברים בהיסטוריה. אם מחרוזת זו תואמת להודעה קבועה שהונפקה
על ידי תוכנית אינטראקטיבית על כתובת socat האחר, מראה ותחושה עקביים יכולים
להיות בארכיון.

בקשה אוֹפְּצִיָה קבוצה

קבוצה זו מכילה אפשרויות שעובדות ברמת הנתונים. שימו לב שהאפשרויות הללו חלות רק
לנתונים ה"גולמיים" המועברים על ידי socat, אך לא לנתוני פרוטוקול המשמשים כתובות כמו
פרוקסי.

cr ממיר את תו סיום השורה ברירת המחדל NL ('\n', 0x0a) ל/מ-CR ('\r',
0x0d) בעת כתיבה/קריאה בערוץ זה.

crnl ממיר את תו ברירת המחדל של סיום השורה NL ('\n', 0x0a) ל/מ-CRNL
("\r\n", 0x0d0a) בעת כתיבה/קריאה בערוץ זה (דוגמה). הערה: socat
פשוט מסיר את כל תווי ה-CR.

מתעלם ממנו
כאשר EOF מתרחש בערוץ זה, סוקט מתעלם ממנו ומנסה לקרוא נתונים נוספים (כמו
"זנב -f") (דוגמה).

readbytes=
סוקט קורא רק כל כך הרבה בתים מהכתובת הזו (הכתובת מספקת רק כל כך הרבה
בתים להעברה ומעמיד פנים שהוא ב-EOF לאחר מכן). חייב להיות גדול מ-0.

lockfile=
אם lockfile קיים, יוצא עם שגיאה. אם lockfile אינו קיים, יוצר אותו ו
ממשיך, מבטל את הקישור ל-lockfile ביציאה.

waitlock=
אם lockfile קיים, ממתין עד שהוא ייעלם. כאשר קובץ הנעילה אינו קיים,
יוצר אותו וממשיך, מבטל את הקישור ל-lockfile ביציאה.

לברוח=
מציין את הקוד המספרי של תו שמפעיל EOF בזרם הקלט. זה
שימושי עם מסוף במצב גולמי (דוגמה).

שֶׁקַע אוֹפְּצִיָה קבוצה

אפשרויות אלו מיועדות לכל מיני שקעים, למשל תחום IP או UNIX. הרוב הם
הוחל עם קריאה setsockopt().

לאגד=
קושר את השקע לכתובת השקע הנתונה באמצעות קריאת המערכת bind() . הצורה
שֶׁל תלוי בדומיין socket: IP4 ו-IP6 מאפשרים את הטופס
[שם מארח|כתובת מארח][:(שירות|יציאה)] (דוגמה), שקעי דומיין UNIX דורשים
.

connect-timeout=
בטל את ניסיון החיבור לאחר [זמן זמן] עם מצב שגיאה.

so-bindtodevice=
קושר את השקע לנתון . אפשרות זו עשויה לדרוש שורש
זכות.

מִשׁדָר
עבור שקעי דאטהגרם, מאפשר שליחת כתובות לשידור וקבלת מנות
ממוען לכתובות שידור.

באגים מאפשר איתור באגים בשקעים.

dontroute
מתקשר רק עם עמיתים מחוברים ישירות, לא משתמש בנתבים.

להשאיר בחיים
מאפשר שליחת שומרים על השקע.

להתעכב =
חוסם shutdown() או close() עד לסיום העברת הנתונים או נתון
פג פסק הזמן [int].

אובינליין
ממקם נתונים מחוץ לפס בזרם נתוני הקלט.

עדיפות=
מגדיר את הפרוטוקול שהוגדר [ ] עבור מנות יוצאות.

rcvbuf=
מגדיר את גודל מאגר הקבלה לאחר הקריאה socket() אל [int]. עם
שקעי TCP, ערך זה מתאים לגודל החלון המרבי של השקע.

rcvbuf-late=
מגדיר את גודל מאגר הקבלה כאשר השקע כבר מחובר אליו
[int]. עם שקעי TCP, ערך זה מתאים לחלון המרבי של השקע
גודל.

rcvlowat=
מציין את המספר המינימלי של בתים שהתקבלו [int] עד ששכבת השקע תעשה זאת
להעביר את הנתונים המאוחסנים ל סוקט.

rcvtimeo=
מגדיר את פסק זמן הקבלה [זמן קצוב].

reuseaddr
מאפשר לשקעים אחרים להיקשר לכתובת גם אם חלקים ממנה (למשל המקומי
port) כבר נמצאים בשימוש על ידי סוקט (דוגמא).

sndbuf=
מגדיר את גודל מאגר השליחה לאחר הקריאה socket() אל [int].

sndbuf-late=
מגדיר את גודל מאגר השליחה כאשר השקע מחובר אליו [int].

sndlowat=
מציין את המספר המינימלי של בתים במאגר השליחה עד לשכבת השקע
ישלח את הנתונים ל [int].

sndtimeo=
מגדיר את פסק זמן השליחה לשניות [זמן זמן].

pf=
מאלץ את השימוש בגרסת ה-IP או בפרוטוקול שצוינו. יכול להיות משהו
כמו "ip4" או "ip6". הערך המתקבל משמש כארגומנט ראשון ל-socket()
או socketpair() קריאות. אפשרות זו משפיעה על רזולוציית הכתובות ועל הדרישה
תחביר של אפשרויות איגד וטווח.

סוג=
מגדיר את סוג השקע, שצוין כארגומנט שני ל-socket() or
socketpair() קורא, to [int]. רזולוציית הכתובת אינה מושפעת מכך
אוֹפְּצִיָה. תחת לינוקס, 1 פירושו שקע מכוון זרם, 2 פירושו שקע דאטהגרם, ו
3 פירושו שקע גולמי.

אב טיפוס
מגדיר את הפרוטוקול של השקע, שצוין כארגומנט שלישי ל-socket() or
socketpair() קורא, to [int]. רזולוציית הכתובת אינה מושפעת מ
אפשרות זו. 6 פירושו TCP, 17 פירושו UDP.

כל כך חותמת זמן
מגדיר את אפשרות השקע SO_TIMESTAMP. זה מאפשר קבלה ורישום של
הודעות נלוות חותמת זמן.

setsockopt-int= : :
מפעיל setsockopt() עבור השקע עם הפרמטרים הנתונים. נעשה שימוש ברמה [int]
כארגומנט שני ל-setsockopt() ומציין את השכבה, למשל SOL_TCP עבור TCP (6
ב-Linux), או SOL_SOCKET עבור שכבת השקע (1 ב-Linux). optname [int] הוא ה-
ארגומנט שלישי ל-setsockopt() ומספר איזו אפשרות socket יש להגדיר. בשביל ה
מספרים בפועל ייתכן שתצטרך לחפש את קבצי הכלול המתאימים שלך
מערכת. הפרמטר ה-4 setsockopt(), ערך [int], מועבר לפונקציה per
מצביע, ועבור פרמטר האורך sizeof\(int) נלקח באופן מרומז.

setsockopt-bin= : :
כמו setsockopt-int, אבל חייב להיות מסופק בפורמט דאלן ומציין
רצף שרירותי של בתים; פרמטר האורך נגזר אוטומטית מה-
נתונים.

setsockopt-string= : :
כמו setsockopt-int, אבל חייב להיות מחרוזת. מחרוזת זו מועברת ל-
פונקציה עם תו אפס נגרר, ופרמטר האורך הוא אוטומטי
נגזר מהנתונים.

UNIX אוֹפְּצִיָה קבוצה

אפשרויות אלה חלות על כתובות מבוססות תחום UNIX.

unix-tightsocklen=[0|1]
בפעולות שקע, העבר אורך כתובת שקע שאינו כולל את כולו
struct sockaddr_un record אבל (מלבד רכיבים אחרים) רק החלק הרלוונטי של
שם הקובץ או המחרוזת המופשטת. ברירת המחדל היא 1.

IP4 ו IP6 אוֹפְּצִיָה קבוצות

ניתן להשתמש באפשרויות אלה עם שקעים מבוססי IPv4 ו-IPv6.

tos=
מגדיר את שדה ה-TOS (סוג שירות) של מנות יוצאות ל [בייט] (ראה RFC
791).

ttl=
מגדיר את שדה ה-TTL (זמן לחיות) של מנות יוצאות ל [בייט].

ip-options=
מגדיר אפשרויות IP כמו ניתוב מקור. חייב להינתן בצורה בינארית, מומלץ
פורמט הוא "x" מוביל ואחריו מספר זוגי של ספרות hex. אפשרות זו עשויה
לשמש מספר פעמים, הנתונים מצורפים. למשל, כדי להתחבר למארח 10.0.0.1 באמצעות
שער כלשהו באמצעות נתיב מקור רופף, השתמש בשער כפרמטר כתובת ו
הגדר מסלול מקור רופף באמצעות האפשרות ip-options=x8307040a000001 .
אפשרויות IP מוגדרות ב-RFC 791.

mtudiscover=<0|1|2>
לוקח 0, 1, 2 כדי לעולם לא, לרצות או להשתמש תמיד בנתיב MTU לגלות בשקע הזה.

ip-pktinfo
מגדיר את אפשרות שקע IP_PKTINFO. זה מאפשר קבלה ורישום של עזר
הודעות המכילות כתובת יעד וממשק (Linux) (דוגמה).

ip-recverr
מגדיר את אפשרות שקע IP_RECVERR. זה מאפשר קבלה ורישום של עזר
הודעות המכילות מידע מפורט על שגיאות.

ip-recvopts
מגדיר את אפשרות השקע IP_RECVOPTS. זה מאפשר קבלה ורישום של IP
אפשרויות הודעות נלוות (Linux, *BSD).

ip-recvtos
מגדיר את אפשרות שקע IP_RECVTOS. זה מאפשר קבלה ורישום של TOS (סוג
של שירות) הודעות נלוות (Linux).

ip-recvttl
מגדיר את אפשרות שקע IP_RECVTTL. זה מאפשר קבלה ורישום של TTL (זמן
לחיות) הודעות נלוות (Linux, *BSD).

ip-recvdstaddr
מגדיר את אפשרות שקע IP_RECVDSTADDR. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות כתובת יעד (*BSD) (דוגמה).

ip-recvif
מגדיר את אפשרות שקע IP_RECVIF. זה מאפשר קבלה ורישום של ממשק
הודעות נלוות (*BSD) (דוגמה).

ip-add-membership=

ip-add-membership=

ip-add-membership=

ip-add-membership=

ip-add-membership=
הופך את השקע לחבר בקבוצת השידור שצוינה. זה כרגע בלבד
מיושם עבור IPv4. האפשרות לוקחת את כתובת ה-IP של קבוצת השידור הרב-שידור ו
מידע על ממשק הרשת הרצוי. התחביר הנפוץ ביותר הוא הראשון,
בעוד שהאחרות זמינות רק במערכות המספקות struct mreqn (Linux).
ניתן להציג את המדדים של ממשקי רשת פעילים באמצעות כלי השירות פרוקן.

ip-multicast-if=
מציין את שם המארח או הכתובת של ממשק הרשת שישמש עבור שידור ריבוי
תְנוּעָה.

ip-multicast-loop=
מציין אם תעבורת ריבוי שידורים יוצאת צריכה לחזור לממשק בלולאה.

ip-multicast-ttl=
מגדיר את ה-TTL המשמש לתעבורה יוצאת של ריבוי שידורים. ברירת המחדל היא 1.

איתור באגים מחדש

res-aaonly

res-usevc

בית ספר ראשוני

res-igntc

מחודשת

הגדרות מחדש

res-stayopen

res-dnsrch
אפשרויות אלו מגדירות את דגלי האפשרויות של הפתרון (רזולוציית השם) המתאימים.
הוסף "=0" כדי לנקות אפשרות ברירת מחדל. ראה man resolver\(5) למידע נוסף על
אפשרויות אלה. הערה: אפשרויות אלה תקפות רק עבור הכתובת שהן מיושמות
ל.

IP6 אוֹפְּצִיָה קבוצה

ניתן להשתמש באפשרויות אלה רק בשקעים מבוססי IPv6. ראה אפשרויות IP עבור אפשרויות שיכולות
מיושם גם על שקעי IPv4 וגם על שקעי IPv6.

ipv6only=
מגדיר את אפשרות השקע IPV6_V6ONLY. אם 0, ערימת ה-TCP תקבל גם היא
חיבורים באמצעות פרוטוקול IPv4 באותה יציאה. ברירת המחדל היא תלוית מערכת.

ipv6-recvdstopts
מגדיר את אפשרות שקע IPV6_RECVDSTOPTS. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות את אפשרויות היעד.

ipv6-recvhoplimit
מגדיר את אפשרות השקע IPV6_RECVHOPLIMIT. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות את ה-hoplimit.

ipv6-recvhopopts
מגדיר את אפשרות שקע IPV6_RECVHOPOPTS. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות את אפשרויות ההופ.

ipv6-recvpktinfo
מגדיר את אפשרות שקע IPV6_RECVPKTINFO. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות כתובת יעד וממשק.

ipv6-unicast-hops=link(TYPE_INT)( )
מגדיר את אפשרות שקע IPV6_UNICAST_HOPS. זה מגדיר את מגבלת ספירת הקפיצות (TTL) עבור
חבילות unicast יוצאות.

ipv6-recvrthdr
מגדיר את אפשרות שקע IPV6_RECVRTHDR. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות מידע ניתוב.

ipv6-tclass
מגדיר את אפשרות שקע IPV6_TCLASS. זה קובע את דרגת ההעברה של יוצאים
חבילות.

ipv6-recvtclass
מגדיר את אפשרות שקע IPV6_RECVTCLASS. זה מאפשר קבלה ורישום של
הודעות נלוות המכילות את מחלקת ההעברה.

TCP אוֹפְּצִיָה קבוצה

אפשרויות אלה עשויות להיות מיושמות על שקעי TCP. הם פועלים על ידי הפעלת setsockopt() עם ה-
פרמטרים מתאימים.

פקק לא שולח מנות קטנות מ-MSS (גודל מקטע מרבי).

לדחות-קבל
בזמן האזנה, מקבל חיבורים רק כאשר הגיעו נתונים מהעמית.

keepcnt=
מגדיר את מספר השומרים לפני כיבוי השקע ל [int].

keepidle=
מגדיר את זמן הסרק לפני שליחת השומר הראשון אל [int].

keepintvl=
מגדיר את המרווח בין שני שומרים ל [int].

להתעכב2=
מגדיר את הזמן לשמור את השקע במצב FIN-WAIT-2 ל [int].

mss=
מגדיר את ה-MSS (גודל המקטע המקסימלי) לאחר הקריאה ל-socket(). [int]. זֶה
לאחר מכן מוצע ערך לעמית עם חבילת SYN או SYN/ACK (דוגמה).

mss-late=
מגדיר את ה-MSS של השקע לאחר חיבור אליו נוצר [int].

השהיית צמתים
מכבה את האלגוריתם של Nagle למדידת RTT (זמן נסיעה הלוך ושוב).

rfc1323
מאפשר אפשרויות RFC1323 TCP: סולם חלונות TCP, מדידת זמן הלוך ושוב (RTTM),
ולהגן מפני מספרי רצף עטופים (PAWS) (AIX).

סטדורג מאפשר טיפול במצביע דחוף תואם RFC1122 (AIX).

syncnt=
מגדיר את המספר המרבי של שידורים חוזרים של SYN במהלך ההתחברות ל [int].

md5sig מאפשר יצירת תקצירי MD5 על החבילות (FreeBSD).

לא משבית את השימוש באפשרויות TCP (FreeBSD, MacOSX).

נופש מגדיר את אפשרות שקע TCP_NOPUSH (FreeBSD, MacOSX).

השק-השבתה
משבית שימוש בתכונת האישור הסלקטיבי (OpenBSD).

הפעלת חתימה
מאפשר יצירת תקצירי MD5 על החבילות (OpenBSD).

סף הפסקה=
מגדיר את זמן ההמתנה לתשובה של העמית בחיבור שנוצר
(HP-UX).

conn-abort-threshold=
מגדיר את זמן ההמתנה לתשובה של השרת במהלך החיבור הראשוני
(HP-UX).

keepinit
מגדיר את זמן ההמתנה לתשובה של השרת במהלך התחברות\() לפני מתן
לְמַעלָה. ערך בחצי שניות, ברירת המחדל היא 150 (75 שניות) (Tru64).

כפות מפעיל את התכונה "הגנה מפני מספרי רצף עטופים" (Tru64).

סאקנה
מאפשר אישור סלקטיבי (Tru64).

tsoptena
מאפשר את אפשרות חותמת הזמן המאפשרת חישוב RTT מחדש בחיבורים קיימים
(Tru64).

SCTP אוֹפְּצִיָה קבוצה

אפשרויות אלה עשויות להיות מיושמות על שקעי זרם SCTP.

sctp-nodelay
מגדיר את אפשרות השקע SCTP_NODELAY המשבית את האלגוריתם של Nagle.

sctp-maxseg=
מגדיר את אפשרות שקע SCTP_MAXSEG ל [int]. לאחר מכן מוצע ערך זה
לעמית עם חבילת SYN או SYN/ACK.

UDP, TCP, ו SCTP אוֹפְּצִיָה קבוצות

כאן אנו מוצאים אפשרויות הקשורות למנגנון יציאת הרשת ולכן ניתן להשתמש בהן
עם כתובות לקוח ושרת UDP, TCP ו-SCTP.

sourceport=
עבור חיבורי TCP ו-UDP יוצאים (לקוח), הוא מגדיר את המקור באמצעות an
extra bind() קריאה. עם כתובות האזנה של TCP או UDP, socat נכבה מיד
החיבור אם הלקוח אינו משתמש ביציאת המקור הזו (דוגמה).

lowport
חיבורי TCP ו-UDP יוצאים (לקוח) עם אפשרות זו משתמשים באקראי שאינו בשימוש
יציאת מקור בין 640 ל-1023 כולל. במערכות הפעלה בכיתה UNIX, זה
דורש הרשאת שורש, ובכך מציין שתהליך הלקוח מורשה
לפי שורש מקומי. כתובות האזנה של TCP ו-UDP עם אפשרות זו נכבות מיד
החיבור אם הלקוח אינו משתמש ב-sourceport <= 1023. מנגנון זה יכול
לספק אישור מוגבל בנסיבות מסוימות.

גרביים אוֹפְּצִיָה קבוצה

בעת שימוש בכתובות מסוג SOCKS, ניתן להגדיר כמה אפשרויות ספציפיות לגרביים.

ספורט גרביים = שירות>
עוקף את ברירת המחדל של שירות "גרביים" או יציאה 1080 עבור יציאת שרת הגרביים עם
.

socksuser=
שולח את [מחרוזת] בשדה שם המשתמש לשרת הגרביים. ברירת המחדל היא ה
שם משתמש בפועל ($LOGNAME או $USER) (דוגמה).

HTTP אוֹפְּצִיָה קבוצה

אפשרויות שניתן לספק עם כתובות מסוג HTTP. כתובת ה-HTTP היחידה כרגע
מיושם הוא proxy-connect.

proxyport= שירות>
עוקף את ברירת המחדל של יציאת פרוקסי HTTP 8080 עם .

מתעלם
פרוטוקול ה-HTTP דורש שימוש ב-CR+NL כמסיים קו. כאשר שרת פרוקסי
מפר תקן זה, ייתכן ש- socat לא יבין את התשובה שלה. אפשרות זו מכוונת
socat לפרש את NL כמסיים קו ולהתעלם מ-CR בתשובה.
עם זאת, socat שולחת CR+NL ל-proxy.

proxyauth= :
ספק אימות "בסיסי" לשרת ה-proxy. הטיעון לאופציה הוא
בשימוש עם כותרת "פרוקסי-הרשאה: בסיס" בצורה מקודדת base64.
הערה: שם משתמש וסיסמה גלויים עבור כל משתמש במחשב המקומי ב-
רשימת תהליכים; שם המשתמש והסיסמה מועברים לשרת ה-proxy ללא מוצפן
(מקודד base64) ועשוי להיות מרחרח.

לפתור
כברירת מחדל, socat שולח ל-proxy בקשת CONNECT המכילה את היעד
שם מארח. עם אפשרות זו, socat פותר את שם המארח באופן מקומי ושולח את ה-IP
כתובת. שימו לב, לפי RFC 2396, רק רזולוציית שמות ל-IPv4
כתובות מיושם.

טווח אוֹפְּצִיָה קבוצה

אפשרויות אלו בודקות אם יש להעניק גישה ללקוח מתחבר. ניתן ליישם אותם
לשקעי רשת האזנה וקבלה. אפשרויות tcp-wrappers נכללות בקבוצה זו.

טווח=
לאחר קבלת חיבור, בודק אם העמית נמצא בפנים רכס. עבור IPv4
כתובות, טווח כתובות מקבל את הצורה כתובת/סיביות, למשל 10.0.0.0/8, או
address:mask, למשל 10.0.0.0:255.0.0.0 (דוגמה); עבור IPv6, זה כן
[ip6-address/bits], למשל [::1/128]. אם כתובת הלקוח אינה תואמת, סוקט
מוציא אזהרה וממשיך להקשיב/לקבל.

tcpwrap[= ]
משתמש בספריית libwrap (tcpd) של Wietse Venema כדי לקבוע אם הלקוח מותר
להתחבר. קבצי התצורה הם /etc/hosts.allow ו /etc/hosts.deny עבור
ברירת מחדל, ראה "man 5 hosts_access" למידע נוסף. האופציונלי (סוּג
string) מועבר לפונקציות העטיפה כשם תהליך הדמון (דוגמה). אם
הושמט, שם הבסיס של קריאת socats (argv[0]) מועבר. אם שניהם tcpwrap
ואפשרויות טווח מוחלות על כתובת, יש למלא את שני התנאים
לאפשר את החיבור.

אפשר-טבלה=
לוקח את הקובץ שצוין במקום /etc/hosts.allow.

deny-table=
לוקח את הקובץ שצוין במקום /etc/hosts.deny.

tcpwrap-etc=
מחפש את hosts.allow ו-hosts.deny בספרייה שצוינה. נדחק על ידי
אפשרויות hosts-allow ו-hosts-deny.

להקשיב אוֹפְּצִיָה קבוצה

אפשרויות ספציפיות לשקעי האזנה.

פיגור=
מגדיר את ערך ה-backlog המועבר עם הקריאה למערכת listen() אל [int].
ברירת המחדל היא 5.

מקסימום-ילדים=
מגביל את מספר תהליכי הצאצא במקביל [int]. ברירת המחדל היא ללא גבול.

ילד אוֹפְּצִיָה קבוצה

אפשרויות עבור כתובות עם מספר קשרים באמצעות תהליכי צאצא.

מזלג לאחר יצירת קשר, מטפל בערוץ שלו בתהליך ילד ושומר
תהליך ההורה מנסה לייצר יותר קשרים, או על ידי הקשבה או
על ידי חיבור בלולאה (דוגמה).
OPENSSL-CONNECT ו-OPENSSL-LISTEN נבדלים זה מזה כאשר הם למעשה חותכים את הילד:

מזלגות OPENSSL-LISTEN לפני לחיצת יד SSL, בעוד OPENSSLSSL-CONNECT מתפצל
לאחר מכן. האפשרויות RETRY ו- FOREVER אינן עוברות בירושה בתהליך הילד.
במערכות הפעלה מסוימות (למשל FreeBSD) אפשרות זו אינה פועלת עבור UDP-LISTEN
כתובות.

EXEC אוֹפְּצִיָה קבוצה

אפשרויות עבור כתובות המפעילות תוכנית.

נתיב=
עוקף את משתנה הסביבה PATH לחיפוש בתוכנה .
ערך $PATH זה יעיל גם בתהליך הילד.

התחבר קידומות argv[0] עבור הקריאה execvp() עם '-', ובכך לגרום למעטפת להתנהג כמו
מעטפת כניסה.

מזלג אוֹפְּצִיָה קבוצה

כתובות EXEC או SYSTEM מפעילות תוכנית באמצעות תהליך צאצא ומעבירות ביניהם נתונים
סוקט והתוכנית. ניתן להשפיע על מנגנון התקשורת הבין-תהליכים עם
האפשרויות הבאות. כברירת מחדל, socketpair() נוצר ומוקצה ל-stdin ו-stdout
של תהליך הילד, בעוד stderr עובר בירושה מה סוקט התהליך, והילד
תהליך משתמש בתיאורי קבצים 0 ו-1 לתקשורת עם תהליך socat הראשי.

נופורק לא מחלק תת-תהליך להפעלת התוכנית, במקום זאת קורא execvp\() or
system\() ישירות ממופע socat בפועל. זה ימנע את התקורה של
תהליך נוסף בין התוכנית לעמיתה, אך מציג הרבה
הגבלות:

o אפשרות זו יכולה להיות מיושמת רק על השני סוקט כתובת.

o לא ניתן להחיל אותו על חלק מכתובת כפולה.

o כתובת socat הראשונה לא יכולה להיות OPENSSL או READLINE

o אפשרויות socat -b, -t, -D, -l, -v, -x הופכות לחסרות תועלת

o עבור שתי הכתובות, האפשרויות ignoreeof, cr ו- crnl הופכות חסרות תועלת

o עבור הכתובת השנייה (זו עם אפשרות nofork), options append, cloexec,
flock, user, group, mode, nonblock, perm-late, setlk ו-setpgid אינם יכולים להיות
מיושם. עם זאת, ניתן להשתמש בחלקם בכתובת הראשונה.

צינורות יוצר זוג צינורות ללא שם לתקשורת בין תהליכים במקום שקע
זוג.

פתוח
יוצר תקשורת עם תהליך המשנה באמצעות מסוף פסאודו שנוצר עם
openpty() במקום ברירת המחדל (socketpair או ptmx).

ptmx יוצר תקשורת עם תהליך המשנה באמצעות מסוף פסאודו שנוצר על ידי
פתיחה / dev / ptmx or /dev/ptc במקום ברירת המחדל (Socketpair).

Pty יוצר תקשורת עם תהליך המשנה באמצעות מסוף פסאודו במקום א
זוג שקעים. יוצר את ה-pty עם מנגנון זמין. אם openpty וptmx הם
שניהם זמינים, הוא משתמש ב-ptmx כי זה תואם POSIX (דוגמה).

ctty הופך את ה-pty ל-tty השולט בתהליך המשנה (דוגמה).

סטדרר מפנה את stderr של תהליך המשנה לערוץ הפלט שלו על ידי הפיכת stderr ל-dup() של
stdout (דוגמה).

fdin=
מקצה את ערוץ הקלט של תהליכי המשנה לתיאור הקובץ שלו במקום
stdin (0). התוכנית שהתחילה מתהליך המשנה צריכה להשתמש ב-fd זה לקריאה
נתונים סוקט (דוגמא).

fdout=
מקצה את ערוץ הפלט של תהליכי המשנה לתיאור הקובץ שלו במקום
stdout (1). התוכנית שהתחילה מתהליך המשנה צריכה להשתמש ב-fd זה לכתיבה
נתונים אל סוקט (דוגמא).

נאנח, חתימה, סיגקווט
יש סוקט להעביר אותות מסוג זה לתהליך המשנה. אם אין כתובת כזו
אפשרות, socat מסתיים על האותות האלה.

TERMIOS אוֹפְּצִיָה קבוצה

עבור כתובות שעובדות על tty (למשל, stdio, file:/dev/tty, exec:...,pty), הטרמינל
פרמטרים המוגדרים במנגנון UN*X termios זמינים כאפשרות כתובת
פרמטרים. שים לב ששינויים בפרמטרים של הטרמינל האינטראקטיבי שלך
להישאר יעיל לאחר סוקטהסיום של, אז ייתכן שיהיה עליך להזין "reset" או "stty
sane" במעטפת שלך לאחר מכן. עבור כתובות EXEC ו-SYSTEM עם אפשרות PTY, אלה
אפשרויות חלות על Pty על ידי תהליכי הילד.

b0 מנתק את המסוף.

b19200 מגדיר את מהירות הקו הטורי ל-19200 באוד. כמה תעריפים אחרים אפשריים; להשתמש
משהו כמו socat -hh |grep ' b[1-9]' כדי למצוא את כל המהירויות הנתמכות על ידי
יישום.
הערה: במערכות הפעלה מסוימות, ייתכן שהאפשרויות הללו לא יהיו זמינות. השתמש ב-ispeed או
ospeed במקום.

הד=
מפעיל או משבית הד מקומי.

iconon=
מגדיר או מנקה מצב קנוני, ומאפשר אחסון שורות וכמה תווים מיוחדים.

חי מגדיר מצב גולמי, ובכך מעביר קלט ופלט כמעט ללא עיבוד. אפשרות זו היא
מיושן, השתמש במקום זאת באפשרות rawer או cfmakeraw.

גס הופך את הטרמינל לגולמי יותר מאשר אפשרות גולמית. אפשרות זו מכבה באופן מרומז הד.
(דוגמא).

cfmakeraw
מגדיר מצב גולמי על ידי הפעלת cfmakeraw() או על ידי הדמיית קריאה זו. אפשרות זו
מכבה באופן מרומז הד.

ignbrk=
מתעלם או מפרש את התו BREAK (למשל, ^C)

brkint=

bs0

bs1

bsdly=<0|1>

מקומי=

cr0
cr1
cr2
cr3

מגדיר את השהיית החזרת הגררה ל-0, 1, 2 או 3, בהתאמה. 0 אומר ללא עיכוב,
הערכים האחרים תלויים במסוף.

crdly=<0|1|2|3>

cread=

crtscts=

cs5
cs6
cs7
cs8

מגדיר את גודל התו ל-5, 6, 7 או 8 סיביות, בהתאמה.

csize=<0|1|2|3>

cstopb=
מגדיר שני סיביות עצירה, במקום אחד.

dsusp=
מגדיר את הערך עבור תו VDSUSP שמשהה את החזית הנוכחית
מעבד ומפעיל מחדש את המעטפת (כולם מלבד לינוקס).

echoctl=
תווי בקרת הד בסימון כובע (למשל ^A)

הד=

echok=

הד=

echonl=

echoprt=

eof=

eol=

eol2=

מחק=

לזרוק=

ff0

ff1

ffdly=

flusho=

hupcl=

icrnl=

iexten=

igncr=

ignpar=

imaxbel=

inlcr=

inpck=

intr=

isig=

ispeed=
הגדר את קצב ההחזרה עבור נתונים נכנסים בקו זה.
ראה גם: ospeed, b19200

istrip=

iuclc=

ixany=

ixoff=

ixon=

להרוג=

הבא=

min=

nl0 מגדיר את השהיה בשורה החדשה ל-0.

nl1

nldly=

noflsh=

ocrnl=

אודל=

ofill=

olcuc=

onlcr=

onlret=

onocr=

opost=
מפעיל או משבית עיבוד פלט; למשל, ממיר NL ל-CR-NL.

ospeed=
הגדר את קצב ההחזרה לנתונים היוצאים בקו זה.
ראה גם: ispeed, b19200

parenb=
אפשר יצירת זוגיות בפלט ובדיקת זוגיות לקלט.

parmrk=

פארוד=

pendin=

עזוב=

הדפסה מחדש=

שָׁפוּי בְּדַעתוֹ מביא את הטרמינל למשהו כמו מצב ברירת מחדל שימושי.

להתחיל=

עצור=

susp=

swtc=

tab0

tab1

tab2

tab3

tabdly=

זמן=

tostop=

vt0

vt1

vtdly=

werase=

xcase=

xtabs

i-pop-all
עם UNIX System V STREAMS, מסיר את כל הדרייברים מהמחסנית.

i-push=
עם UNIX System V STREAMS, דוחף את הדרייבר (מודול) עם השם הנתון (מחרוזת)
על הערימה. לדוגמה, כדי לוודא שהתקן תו על Solaris
תומך ב-termios וכו', השתמש באפשרויות הבאות:
i-pop-all,i-push=ptem,i-push=ldterm,i-push=ttcompat

PTY אוֹפְּצִיָה קבוצה

אפשרויות אלו מיועדות לשימוש עם סוג כתובת pty.

קישור=
יוצר קישור סמלי המצביע למסוף הפסאודו בפועל (pty). זֶה
עשוי לעזור לפתור את הבעיה ש-ptys נוצרים איתם יותר או פחות
שמות בלתי צפויים, מה שמקשה על גישה ישירה ל-pty שנוצר על ידי socat
אוטומטית. עם אפשרות זו, המשתמש יכול לציין נקודת "תיקון" בקובץ
היררכיה שעוזרת לו לגשת ל-pty בפועל (דוגמה). מתחיל ב סוקט
גרסה 1.4.3, הקישור הסמלי מוסר כאשר הכתובת סגורה (אך ראה
אפשרות unlink-close).

לחכות-עבד
חוסם את השלב הפתוח עד שתהליך פותח את צד העבד של ה-pty. בְּדֶרֶך כְּלַל,
socat ממשיך לאחר יצירת ה-pty עם פתיחת הכתובת הבאה או עם
כניסה ללולאת ההעברה. עם אפשרות המתנה-עבד, socat מחכה עד כמה
התהליך פותח את הצד העבד של ה-pty לפני המשך. אפשרות זו פועלת רק
אם מערכת ההפעלה מספקת את קריאת המערכת poll() . וזה תלוי ב-
התנהגות לא מתועדת של Pty's, כך שזה לא עובד בכל מערכות ההפעלה. זה
נבדק בהצלחה על Linux, FreeBSD, NetBSD וב-Tru64 עם openpty.

pty-interval=
כאשר אפשרות המתנה-עבד מוגדרת, socat בודק מעת לעת את מצב HUP
באמצעות poll() כדי למצוא אם הצד העבד של ה-pty נפתח. ברירת המחדל של הסקרים
המרווח הוא 1 שניות. השתמש באפשרות pty-interval [timeval] כדי לשנות ערך זה.

OPENSSL אוֹפְּצִיָה קבוצה

אפשרויות אלו חלות על סוגי הכתובות openssl ו-openssl-listen.

צופן=
בוחר את רשימת הצפנים שניתן להשתמש בהם עבור החיבור. עיין בדף האיש
של צפנים, סעיף צופן רשימה פורמט, למידע מפורט על תחביר,
ערכים, וברירת המחדל של .
ניתן לתת כמה מחרוזות צופן, מופרדות ב-':'. כמה מחרוזות צופן פשוטות:

3DES משתמש בחבילת צופן עם DES משולש.

MD5 משתמש בחבילת צופן עם MD5.

aNULL משתמש בחבילת צופן ללא אימות.

NULL אינו משתמש בהצפנה.

HIGH משתמש בחבילת צופן עם הצפנה "גבוהה". שימו לב שהעמית חייב לתמוך ב
הנכס שנבחר, אחרת המשא ומתן ייכשל.

שיטה=
מגדיר את גרסת הפרוטוקול לשימוש. מחרוזות חוקיות (לא תלויות רישיות) הן:

SSL2 בחר פרוטוקול SSL גרסה 2.

SSL3 בחר פרוטוקול SSL גרסה 3.

SSL23 בחר את פרוטוקול SSL או TLS הטוב ביותר הזמין. זוהי ברירת המחדל כאשר אפשרות זו
אינו מסופק.

TLS1 בחר פרוטוקול TLS גרסה 1.

TLS1.1 בחר פרוטוקול TLS גרסה 1.1.

TLS1.2 בחר פרוטוקול TLS גרסה 1.2.

DTLS1 בחר פרוטוקול DTLS גרסה 1.

לאמת=
שולט בבדיקת תעודת העמית. ברירת המחדל היא 1 (נכון). משבית את האימות
עשוי לפתוח את השקע שלך לכולם, מה שהופך את ההצפנה חסרת תועלת!

cert=
מציין את הקובץ עם האישור והמפתח הפרטי לאימות. ה
האישור חייב להיות בפורמט OpenSSL (*.pem). עם openssl-האזנה, השתמש בזה
האפשרות מומלצת בחום. למעט עם cipher aNULL, שגיאת "אין צפנים משותפים".
יתרחש כאשר לא ניתן אישור.

מפתח=
מציין את הקובץ עם המפתח הפרטי. המפתח הפרטי עשוי להיות בקובץ זה או בקובץ זה
הקובץ שניתן עם אפשרות ה-cert. הצד שצריך להוכיח שזהו
בעל תעודה צריך את המפתח הפרטי.

dhparams=
מציין את הקובץ עם הפרמטרים של דיפי הלמן. פרמטרים אלה עשויים להיות גם
בקובץ שניתן עם אפשרות cert ובמקרה זה האפשרות dhparams אינה
נָחוּץ.

cafile=
מציין את הקובץ עם אישורי הרשות המהימנים (השורשיים). הקובץ חייב להיות
בפורמט PEM וצריך להכיל תעודה אחת או יותר. הצד שבודק
האימות של עמיתיו נותן אמון רק באישורים שנמצאים בקובץ זה.

capath=
מציין את הספרייה עם האישורים המהימנים (השורש). הספרייה חייבת
מכיל אישורים בפורמט PEM וה-hash שלהם (ראה תיעוד OpenSSL)

egd=
במערכות מסוימות, openssl דורש מקור מפורש של נתונים אקראיים. ציין את
שם שקע שבו דמון אוסף אנטרופיה כמו egd מספק נתונים אקראיים, למשל
/dev/egd-pool.

מדומה במערכות שבהן openssl לא יכול למצוא מקור אנטרופיה ושאין אנטרופיה
ניתן להשתמש באיסוף דמון, אפשרות זו מפעילה מנגנון לספק
פסאודו אנטרופיה. זה מאוחסן בארכיון על ידי לקיחת הזמן הנוכחי במיקרו-שניות עבור
הזנה של מחולל המספרים האקראיים הפסאודו libc עם ערך התחלתי. openssl הוא
לאחר מכן הוזנה עם פלט מקריאות אקראיות\().
הערה: מנגנון זה אינו מספיק ליצירת מפתחות מאובטחים!

לדחוס
אפשר או השבת את השימוש בדחיסה עבור חיבור. מגדיר את זה ל"ללא"
משבית את הדחיסה, הגדרתו ל"אוטומטי" מאפשרת ל-OpenSSL לבחור את הטוב ביותר שזמין
אלגוריתם נתמך על ידי שני הצדדים. ברירת המחדל היא לא לגעת באף אחד
הגדרות הקשורות לדחיסה. הערה: דורש OpenSSL 0.9.8 ומעלה והשבתה
דחיסה עם OpenSSL 0.9.8 משפיעה על כל החיבורים החדשים בתהליך.

שם משותף=
ציין את השם הנפוץ שאישור העמית חייב להתאים. עם OPENSSL-CONNECT
כתובת זו עוקפת את שם המארח או כתובת יעד ה-IP הנתונה; עם OPENSSL-LISTEN
זה מפעיל את בדיקת אישורי עמיתים. לאפשרות זו יש משמעות בלבד
כאשר האפשרות אימות אינה מושבתת והצופן הנבחר מספק עמית
תעודה.

פיפס מפעיל מצב FIPS אם הוא מורכב. למידע על יישום ההצפנה של FIPS
סטנדרטי לראות http://oss-institute.org/fips-faq.html. מצב זה עשוי לדרוש זאת
האישורים המעורבים נוצרים עם גרסה מאופשרת של FIPS של openssl.
הגדרה או ניקוי של אפשרות זו בכתובת socat אחת משפיעה על כל כתובות OpenSSL
של תהליך זה.

נסה שוב אוֹפְּצִיָה קבוצה

אפשרויות השולטות בניסיון חוזר של כמה שיחות מערכת, במיוחד ניסיונות חיבור.

נסה שוב=
מספר הניסיונות החוזרים לפני ביטול החיבור או ניסיון ההאזנה. ברירת המחדל היא
0, כלומר ניסיון אחד בלבד.

מרווח=
זמן בין ניסיונות רצופים (שניות, [מפרט זמן]). ברירת המחדל היא שנייה אחת.

לנצח
מבצע מספר בלתי מוגבל של ניסיונות ניסיון חוזר.

חבית גדולה אוֹפְּצִיָה קבוצה

אפשרויות השולטות בכתובות של ממשק TUN/TAP של Linux.

tun-device=
מורה ל-socat לקחת נתיב אחר עבור מכשיר השיבוט של TUN. ברירת המחדל היא
/dev/net/tun.

tun-name=
נותן לממשק הרשת שנוצר שם ספציפי במקום המערכת
נוצר (tun0, tun1 וכו')

tun-type=[tun|tap]
מגדיר את סוג התקן ה-TUN; השתמש באפשרות זו כדי ליצור התקן TAP. ראה את
דוקו לינוקס עבור ההבדל בין הסוגים הללו. כאשר אתה מנסה להקים א
מנהרה בין שני התקני TUN, הסוגים שלהם צריכים להיות זהים.

אם-לא-פי
מגדיר את דגל IFF_NO_PI השולט אם המכשיר כולל מנות נוספות
מידע במנהרה. כאשר אתה מנסה להקים מנהרה בין שני TUN
מכשירים, דגלים אלה צריכים להיות בעלי אותם ערכים.

אם למעלה מגדיר את מצב ממשק הרשת TUN למעלה. מומלץ בחום.

שידור iff
מגדיר את דגל ה-BROADCAST של ממשק הרשת TUN.

iff-debug
מגדיר את דגל DEBUG של ממשק הרשת TUN.

iff-loopback
מגדיר את דגל LOOPBACK של ממשק הרשת TUN.

iff-pointopoint
מגדיר את הדגל POINTOPOINT של מכשיר ה-TUN.

iff-notrailers
מגדיר את דגל ה-NOTRAILERS של מכשיר ה-TUN.

אם פועל
מגדיר את דגל RUNNING של מכשיר ה-TUN.

אם-נוארפ
מגדיר את דגל NOARP של מכשיר ה-TUN.

iff-promisc
מגדיר את דגל PROMISC של מכשיר ה-TUN.

iff-allmulti
מגדיר את דגל ALLMULTI של מכשיר ה-TUN.

אם-מאסטר
מגדיר את דגל ה-MASTER של מכשיר ה-TUN.

אם-עבד
מגדיר את דגל ה-SLAVE של מכשיר ה-TUN.

iff-multicast
מגדיר את דגל MULTICAST של מכשיר ה-TUN.

iff-portsel
מגדיר את דגל ה-PORTSEL של מכשיר ה-TUN.

iff-אוטומדיה
מגדיר את דגל AUTOMEDIA של מכשיר ה-TUN.

iff דינמי
מגדיר את הדגל DYNAMIC של מכשיר ה-TUN.

נתונים ערכים

סעיף זה מסביר את סוגי הנתונים השונים המטפלים בפרמטרים ואפשרויות כתובת
יכול לקחת.

טווח כתובות
מיושם כרגע רק עבור IPv4 ו- IPv6. ראה את אפשרות הכתובת 'טווח'

bool "0" או "1"; אם הערך מושמט, "1" נלקח.

byte מספר int ללא סימן, נקרא עם strtoul() , נמוך או שווה ל-UCHAR_MAX.

שורת הפקודה
מחרוזת המציינת שם תוכנית והארגומנטים שלה, מופרדים ברווחים בודדים.

נתונים מפרט נתונים גולמי הבא סניף תחביר. נכון לעכשיו הטופס התקף היחיד הוא א
מחרוזת שמתחילה ב-'x' ואחריה מספר זוגי של ספרות hex, תוך ציון a
רצף של בתים.

בספרייה
מחרוזת עם סמנטיקה רגילה של שם ספריות UN*X.

מתקן
שם מתקן syslog באותיות קטנות.

fdnum סוג int לא חתום, נקרא עם strtoul() , המציין מתאר קובץ UN*X.

שם הקובץ
מחרוזת עם סמנטיקה רגילה של שמות UN*X.

group אם התו הראשון הוא ספרה עשרונית, הערך נקרא עם strtoul() as
מספר שלם לא חתום המציין מזהה קבוצה. אחרת, זו חייבת להיות קבוצה קיימת
שם.

int מספר העוקב אחר הכללים של הפונקציה strtol() עם בסיס "0", כלומר עשרוני
מספר, מספר אוקטלי עם "0" מוביל, או מספר הקסדצימלי עם "0x" מוביל. ה
הערך חייב להתאים ל-C int.

ממשק
מחרוזת המציינת את שם ההתקן של ממשק רשת כפי שמוצג על ידי ifconfig או
פרוקן, למשל "eth0".

כתובת ה-IP
כתובת IPv4 בסימון מספרים ונקודות, כתובת IPv6 בסימון משושה
מוקף בסוגריים, או שם מארח הפונה לכתובת IPv4 או IPv6.
דוגמאות: 127.0.0.1, [::1], www.dest-unreach.org, dns1

כתובת IPv4
כתובת IPv4 בסימון של מספרים ונקודות או שם מארח שמתפנה ל-IPv4
כתובת.
דוגמאות: 127.0.0.1, www.dest-unreach.org, dns2

כתובת IPv6
כתובת iPv6 בסימון מספרי hex ונקודתיים מוקפת בסוגריים, או
שם מארח שפותר לכתובת IPv6.
Examples: [::1], [1234:5678:9abc:def0:1234:5678:9abc:def0], ip6name.domain.org

long מספר שנקרא עם strtol() . הערך חייב להתאים ל-C long.

ארוך ארוך
מספר שנקרא עם strtoll() . הערך חייב להתאים ל-C long long.

off_t מספר חתום תלוי יישום, בדרך כלל 32 סיביות, נקרא עם strtol או
strtoll.

off64_t
מספר חתום תלוי יישום, בדרך כלל 64 סיביות, נקרא עם strtol או
strtoll.

mode_t מספר שלם ללא סימן, נקרא עם strtoul() , המציין סיביות מצב (הרשאה).

pid_t מספר, קרא עם strtol() , המציין מזהה תהליך.

יציאה A uint16_t (מספר 16 סיביות לא חתום) המציין יציאת TCP או UDP, קרא עם
strtoul() .

פרוטוקול
מספר 8 סיביות ללא סימן, נקרא עם strtoul() .

size_t מספר לא חתום עם מגבלות size_t, קרא עם strtoul .

שם גרב
כתובת שקע. ראה את אפשרות הכתובת 'קשר'

מחרוזת רצף של תווים, שאינו מכיל '\0' ובהתאם למיקום בתוכו
שורת הפקודה, ':', ',' או "!!". שים לב שייתכן שתצטרך להימלט ממטא מעטפת
תווים בשורת הפקודה.

שירות TCP
שם שירות, שאינו מתחיל בספרה, שנפתר על ידי getservbyname() , או
מספר int 16 סיביות ללא סימן שנקרא עם strtoul() .

זמן
ציפה כפולה המציינת שניות; המספר ממופה לטווח זמן של מבנה,
המורכבת משניות ומיקרו שניות.

מפרט זמן
ציפה כפולה המציינת שניות; המספר ממופה למפרט זמן של מבנה,
המורכבת משניות וננו-שניות.

שירות UDP
שם שירות, שאינו מתחיל בספרה, שנפתר על ידי getservbyname() , או
מספר int 16 סיביות ללא סימן שנקרא עם strtoul() .

לא חתום
מספר שנקרא עם strtoul() . הערך חייב להתאים ל-int C ללא סימן.

user אם התו הראשון הוא ספרה עשרונית, הערך נקרא עם strtoul() as
מספר שלם לא חתום המציין מזהה משתמש. אחרת, זה חייב להיות שם משתמש קיים.

דוגמאות

סוקט - TCP4:www.domain.org:80

מעביר נתונים בין STDIO (-) וחיבור TCP4 ליציאה 80 של המארח
www.domain.org. דוגמה זו מביאה לחיבור אינטראקטיבי בדומה ל-telnet
או netcat. הפרמטרים של מסוף stdin אינם משתנים, אז אתה יכול לסגור את
העבר עם ^D או בטל אותו עם ^C.

סוקט -d -d READLINE,history=$HOME/.http_history \
TCP4:www.domain.org:www,crnl

זה דומה לדוגמה הקודמת, אבל אתה יכול לערוך את השורה הנוכחית ב-a
bash like manner (READLINE) והשתמש בקובץ ההיסטוריה .http_history; סוקט הדפסים
הודעות על התקדמות (-d -d). היציאה מצוינת לפי שם השירות (www), ו
נעשה שימוש בתווי סיום קו רשת נכונים (crnl) במקום NL.

סוקט TCP4-LISTEN:www TCP4:www.domain.org:www

מתקין מעביר יציאות TCP פשוט. עם TCP4-LISTEN הוא מאזין ביציאה מקומית
"www" עד שנכנס חיבור, מקבל אותו ואז מתחבר למארח המרוחק
(TCP4) ומתחיל העברת נתונים. זה לא יקבל חיבור שני.

סוקט -d -d -lmlocal2 \
TCP4-LISTEN:80,bind=myaddr1,reuseaddr,fork,su=nobody,range=10.0.0.0/8 \
TCP4:www.domain.org:80,bind=myaddr2

מעביר יציאות TCP, כל צד קשור לכתובת IP מקומית אחרת (bind). זֶה
דוגמה מטפלת במספר כמעט שרירותי של חיבורים מקבילים או עוקבים
על ידי העברת תהליך חדש לאחר כל accept() . זה מספק מעט אבטחה על ידי
סוינג לאף אחד לאחר התפצלות; זה מאפשר רק חיבורים מהפרטי
10 רשת (טווח); עקב reuseaddr, הוא מאפשר הפעלה מחדש מיידית לאחר מאסטר
סיום התהליך, גם אם חלק משקעי הילדים אינם כבויים לחלוטין.
עם -lmlocal2, socat מתחבר ל-stderr עד שמגיעים בהצלחה ללולאת accept.
רישום נוסף מופנה ל-syslog עם מתקן local2.

סוקט TCP4-LISTEN:5555,fork,tcpwrap=script \
EXEC:/bin/myscript,chroot=/home/sandbox,su-d=sandbox,pty,stderr

שרת פשוט שמקבל חיבורים (TCP4-LISTEN) ומזלג הוא ילד חדש
תהליך עבור כל חיבור; כל ילד פועל כממסר יחיד. הלקוח חייב
להתאים את הכללים עבור שם תהליך דמון "סקריפט" ב /etc/hosts.allow ו
/etc/hosts.deny, אחרת היא תידחה גישה (ראה "איש 5 hosts_access"). ל
תוך הפעלת התוכנית, תהליך הילד chroot's to /home/ארגז חול, זה למשתמש
ארגז חול, ולאחר מכן מפעיל את התוכנית /home/sandbox/bin/myscript. סוקאט והכתב שלי
לתקשר באמצעות Pseudo tty (pty); ה-stderr של myscript מופנה ל-stdout, אז
הודעות השגיאה שלו מועברות באמצעות סוקט ללקוח המחובר.

סוקט EXEC:"mail.sh [מוגן בדוא"ל]",fdin=3,fdout=4 \
TCP4:mail.relay.org:25,crnl,bind=alias1.server.org,mss=512

mail.sh הוא תסריט מעטפת, מופץ עם סוקט, שמיישם SMTP פשוט
לָקוּחַ. הוא מתוכנת "לדבר" SMTP ב-FDs 3 (in) ו-4 (out). ה-fdin
ואפשרויות fdout מספרות סוקט להשתמש ב-FDs אלה לתקשורת עם התוכנית.
כי mail.sh יורש stdin ו-stdout while סוקט לא משתמש בהם, בסקריפט
יכול לקרוא גוף דואר מ-stdin. סוקאט הופך את alias1 לכתובת המקור המקומית שלך
(bind), דואג לסיום קו רשת נכון (crnl) ושולח לכל היותר 512
בתים של נתונים לכל מנה (mss).

סוקט -,escape=0x0f /dev/ttyS0,rawer,crnl

פותח חיבור אינטראקטיבי דרך הקו הטורי, למשל לשיחה עם מודם.
rawer מגדיר את פרמטרי הטרמינל של הקונסולה ושל ttyS0 לערכים מעשיים,
crnl ממיר לתווים נכונים בשורה חדשה. בריחה מאפשרת לסיים את הסוקט
תהליך עם שליטה בתווים-O.

סוקט UNIX-LISTEN:/tmp/.X11-unix/X1,מזלג \
SOCKS4:host.victim.org:127.0.0.1:6000,socksuser=nobody,sourceport=20

עם UNIX-LISTEN, סוקט פותח שקע תחום UNIX מאזין /tmp/.X11-unix/X1.
נתיב זה מתאים לתצוגה המקומית של XWindow :1 במחשב שלך, אז XWindow
חיבורי לקוח ל-DISPLAY=:1 מתקבלים. סוקאט ואז מדבר עם SOCKS4
שרת host.victim.org שעשוי לאפשר חיבורים מבוססי sourceport 20 עקב א
חולשה הקשורה ל-FTP במסנני ה-IP הסטטיים שלו. סוקאט מתיימר להיות מופעל על ידי
socksuser אף אחד, ומבקש להיות מחובר ליציאת loopback 6000 (חלש בלבד
תצורות sockd יאפשרו זאת). אז אנחנו מקבלים קשר לקורבנות
שרת XWindow, ואם הוא אינו מצריך קובצי Cookie של MIT או אימות Kerberos,
נוכל להתחיל לעבוד. שימו לב שיכול להיות רק חיבור אחד בכל פעם,
כי TCP יכול להקים רק הפעלה אחת עם קבוצה נתונה של כתובות ויציאות.

סוקט -u /tmp/readdata,seek-end=0,ignoreeof -

זוהי דוגמה להעברת נתונים חד-כיוונית (-u). סוקאט מעביר נתונים מ
קובץ /tmp/readdata (כתובת מרומזת GOPEN), החל מהקצה הנוכחי שלו
(seek-end=0 מאפשר סוקט התחל לקרוא בסוף הקובץ הנוכחי; השתמש ב-seek=0 או ללא חיפוש
אפשרות לקרוא תחילה את הנתונים הקיימים) במצב כמו "tail -f" (התעלם ממנו). ה
"קובץ" עשוי להיות גם שקע תחום UNIX מאזין (אל תשתמש באפשרות חיפוש
לאחר מכן).

(לִישׁוֹן 5; הד סיסמה; לִישׁוֹן 5; הד ls; לִישׁוֹן 1) |
סוקט - EXEC:'שש -l המשתמש server',pty,setsid,ctty

EXEC'utes הפעלת ssh לשרת. משתמש ב-pty לתקשורת בין סוקט ו
ssh, הופך אותו ל-tty השולט של ssh (ctty), והופך את ה-pty הזה לבעלים של חדש
process group (setsid), אז ssh מקבל את הסיסמה מ סוקט.

סוקט -u TCP4-LISTEN:3334,reuseaddr,fork \
פתח:/tmp/in.log,creat,append

מיישם אוסף הודעות פשוט מבוסס רשת. לכל לקוח שמתחבר אליו
יציאה 3334, נוצר תהליך צאצא חדש (אפשרות למזלג). כל הנתונים שנשלחו על ידי
לקוחות מצורפים לקובץ /tmp/in.log. אם הקובץ לא קיים, socat
יצירת זה. אפשרות reuseaddr מאפשרת הפעלה מחדש מיידית של תהליך השרת.

סוקט PTY,link=$HOME/dev/vmodem0,rawer,wait-slave \
EXEC:"ssh modemserver.us.org סוקט - /dev/ttyS0,nonblock,rawer"

יוצר התקן פסאודו מסוף (PTY) בלקוח שניתן להגיע אליו תחתיו
הקישור הסמלי $HOME/dev/vmodem0. אפליקציה שמצפה לקו סדרתי או
ניתן להגדיר את המודם לשימוש $HOME/dev/vmodem0; התנועה שלו תופנה אל א
שרת מודם דרך ssh שבו מופע אחר של socat מקשר אותו אליו /dev/ttyS0.

סוקט TCP4-LISTEN:2022,reuseaddr,fork \
PROXY:proxy:www.domain.org:22,proxyport=3128,proxyauth=user:pass

מפעיל משלח שמקבל חיבורים ביציאה 2022, ומכוון אותם דרכם
דמון ה-proxy מאזין ביציאה 3128 (proxyport) ב-proxy המארח, באמצעות ה-
שיטת CONNECT, שבה הם מאומתים כ"משתמש" עם "pass" (proxyauth). ה
פרוקסי צריך ליצור חיבורים לארח www.domain.org ביציאה 22.

סוקט - OPENSSL:server:4443,cafile=server.crt,cert=client.pem

הוא לקוח OpenSSL שמנסה ליצור חיבור מאובטח לשרת SSL.
Option cafile מציין קובץ המכיל אישורי אמון: אנחנו סומכים על
שרת רק כאשר הוא מציג אחד מהאישורים הללו והוכחות שהוא הבעלים של
מפתח פרטי קשור. אחרת החיבור נפסק. עם קובץ cert a
המכיל את אישור הלקוח והמפתח הפרטי המשויך מצויין. זֶה
נדרש במקרה שהשרת מעוניין באימות לקוח; אינטרנט רבים
שרתים לא.
את הכתובת הראשונה ('-') ניתן להחליף כמעט בכל כתובת socat אחרת.

סוקט OPENSSL-LISTEN:4443,reuseaddr,pf=ip4,fork,cert=server.pem,cafile=client.crt צינור

הוא שרת OpenSSL שמקבל חיבורי TCP, מציג את האישור מ
הקובץ server.pem ומאלץ את הלקוח להציג אישור מאומת
נגד cafile.crt.
את הכתובת השנייה ('PIPE') ניתן להחליף כמעט בכל כתובת socat אחרת.
להנחיות על יצירה והפצה של מפתחות ואישורי OpenSSL ראה
socat דוקו נוסף socat-openssl.txt.

הד |socat -u - file:/tmp/bigfile,create,largefile,seek=100000000000

יוצר קובץ דל של 100GB; זה דורש סוג מערכת קבצים שתומך בזה
(ext2, ext3, reiserfs, jfs; לא minix, vfat). פעולת כתיבת 1 בייט עשויה
לוקח זמן רב (reiserfs: כמה דקות; ext2: "לא" זמן), והקובץ המתקבל יכול
לצרוך קצת מקום בדיסק רק עם האינודים שלו (reiserfs: 2MB; ext2: 16KB).

סוקט tcp-l:7777,reuseaddr,fork מערכת:'פילן -i 0 -s >&2',nofork

מאזין לחיבורי TCP נכנסים ביציאה 7777. עבור כל חיבור מקובל,
מפעיל פגז. למעטפת הזו יש stdin ו-stdout מחוברים ישירות ל-TCP
שקע (nofork). המעטפת מפעילה פילאן ונותנת לו להדפיס את כתובות השקע
stderr (חלון הטרמינל שלך).

הד -en "\0\14\0\0\c" |socat -u - file:/usr/bin/squid.exe,seek=0x00074420

מתפקד כעורך בינארי פרימיטיבי: הוא כותב את 4 הבתים 000 014 000 000 ל-
קובץ הפעלה /usr/bin/squid ב-offset 0x00074420 (זהו תיקון עולם אמיתי שצריך לעשות
קובץ ההפעלה של דיונון מ-Cygwin פועל תחת Windows, בפועל במאי 2004).

סוקט - tcp:www.blackhat.org:31337,readbytes=1000

מתחבר לשירות לא ידוע ומונע הצפה.

סוקט -U TCP:target:9999,end-close TCP-L:8888,reuseaddr,fork

ממזג נתונים המגיעים מזרמי TCP שונים ביציאה 8888 לזרם אחד בלבד
יעד: 9999. אפשרות סגירת הקצה מונעת את תהליכי הילד שחולקו על ידי
כתובת שנייה מסיום החיבור המשותף ל-9999 (סגור\(2) רק
מבטל את הקישור של האינוד שנשאר פעיל כל עוד תהליך האב חי;
כיבוי\(2) יפסיק את החיבור באופן פעיל).

סוקט - UDP4-DATAGRAM:192.168.1.0:123,sp=123,broadcast,range=192.168.1.0/24

שולח שידור לרשת 192.168.1.0/24 ומקבל את התשובות של
שרתי זמן שם. מתעלם מחבילות NTP ממארחים מחוץ לרשת זו.

סוקט - SOCKET-DATAGRAM:2:2:17:x007bxc0a80100x0000000000000000,b‐
ind=x007bx00000000x0000000000000000,setsockopt-int=1:6:1,r‐
ange=x0000xc0a80100x0000000000000000:x0000xffffff00x0000000000000000

שווה מבחינה סמנטית לדוגמא הקודמת, אבל כל הפרמטרים כן
מצוין בצורה גנרית. הערך 6 של setsockopt-int הוא הערך של לינוקס עבור
SO_BROADCAST.

סוקט - IP4-DATAGRAM:255.255.255.255:44,broadcast,range=10.0.0.0/8

שולח שידור לרשת\(ים) המקומית באמצעות פרוטוקול 44. מקבל תשובות מאת
טווח הכתובות הפרטיות בלבד.

סוקט - UDP4-DATAGRAM:224.255.0.1:6666,bind=:6666,ip-add-membership=224.255.0.1:eth0

מעביר נתונים מ-stdin לכתובת ה-multicast שצוינה באמצעות UDP. שניהם מקומיים
ויציאות מרוחקות הן 6666. אומר לממשק eth0 לקבל גם שידור רב
מנות של הקבוצה הנתונה. מארחים מרובים ברשת המקומית יכולים להפעיל זאת
הפקודה, כך שכל הנתונים שנשלחו על ידי כל אחד מהמארחים יתקבלו על ידי כל האחרים
יחידות. שימו לב שישנן סיבות אפשריות רבות לכשל, כולל מסנני IP,
בעיות ניתוב, בחירת ממשק שגויה על ידי מערכת ההפעלה, גשרים או א
מתג מוגדר בצורה גרועה.

סוקט TCP:host2:4443 TUN:192.168.255.1/24, למעלה

מקים צד אחד של רשת וירטואלית (אך לא פרטית!) עם host2 כאשר א
תהליך דומה עשוי לפעול, עם UDP-L וכתובת tun 192.168.255.2. הם יכולים להגיע
זה את זה באמצעות הכתובות 192.168.255.1 ו-192.168.255.2. שימו לב שסטרימינג
לְמָשָׁל. באמצעות TCP או SSL אינם מבטיחים לשמור על גבולות מנות ולכן עלולים
לגרום לאובדן מנות.

סוקט PTY,link=/var/run/ppp,rawer ממשק:hdlc0

עוקף את הבעיה ש-pppd דורש התקן טורי ולכן ייתכן שלא
מסוגל לעבוד על קו סינכרוני שמיוצג על ידי התקן רשת. socat
יוצר PTY כדי לשמח את pppd, נקשר לממשק הרשת hdlc0, ויכול
להעביר נתונים בין שני המכשירים. השתמש ב-pppd במכשיר /var/run/ppp לאחר מכן.

סוקט -T 1 -d -d TCP-L:10081,reuseaddr,fork,crlf מערכת: "הד -e \"\\\"HTTP/1.0 200
אישור\\\nסוג מסמך: טקסט/רגיל\\\n\\\nתאריך:
\$\(תאריך\)\\\nשרת:\$SOCAT_SOCKADDR:\$SOCAT_SOCKPORT\\\nclient:
\$SOCAT_PEERADDR:\$SOCAT_PEERPORT\\\n\\\"\"; חתול; הד -e \"\\\"\\\n\\\"\""

יוצר שרת HTTP הד פשוט: כל לקוח HTTP שמתחבר מקבל HTTP חוקי
תשובה המכילה מידע על כתובת הלקוח והיציאה כפי שהיא נראית על ידי
מארח השרת, כתובת המארח (שעשויה להשתנות בשרתים מרובי-הומדים), וה-
בקשת הלקוח המקורית.

סוקט -d -d
UDP4-RECVFROM:9999,so-broadcast,so-timestamp,ip-pktinfo,ip-recverr,ip-recvopts,ip-recvtos,ip-recvttl!!-
SYSTEM:'ייצוא; לִישׁוֹן 1 ' |grep SOCAT

ממתין לחבילת UDP נכנסת ביציאה 9999 ומדפיס את משתני הסביבה
מסופק על ידי socat. במערכות מבוססות BSD אתה צריך להחליף את ip-pktinfo עם
ip-recvdstaddr,ip-recvif. מעניין במיוחד הוא SOCAT_IP_DSTADDR: הוא מכיל
כתובת היעד של החבילה שעשויה להיות שידור חד-שידור, שידור מרובה-שידור או שידור
כתובת.

דיאגנוסטיקה

סוקאט משתמש במנגנון רישום המאפשר לסנן הודעות לפי חומרה. החומרות
המסופקים תואמים פחות או יותר לעדיפות ה-syslog המתאימה. עם אחד או עד
ארבע מופעים של אפשרות שורת הפקודה -d, העדיפות הנמוכה ביותר של הודעות שיש
ניתן לבחור. כל הודעה מכילה תו גדול בודד המציין את
חומרת ההודעות (אחד מ-F, E, W, N, I, או D)

פטאל: תנאים המחייבים הפסקת תוכנית ללא תנאי ומיד.

שגיאה: תנאים המונעים עיבוד תקין של התוכנית. בדרך כלל התוכנית היא
הסתיים (ראה אפשרות -ים).

אזהרה:
משהו לא תפקד כראוי או שהוא במצב שבו נכון יותר
לא ניתן להבטיח את העיבוד, אך עשוי להיות אפשרי.

שים לב:
פעולות מעניינות של התוכנית, למשל לפיקוח סוקט באיזשהו סוג של
מצב שרת.

מידע: תיאור של מה שהתוכנית עושה, ואולי למה זה קורה. מאפשר לפקח
מחזורי החיים של מתארי קבצים.

DEBUG: תיאור של אופן פעולת התוכנית, כל קריאות המערכת או הספרייה והן
תוצאות.

ניתן לכתוב הודעות יומן ל-stderr, לקובץ או ל-syslog.

ביציאה, סוקט נותן סטטוס 0 אם הוא הסתיים עקב EOF או פסק זמן של חוסר פעילות, עם א
ערך חיובי על טעות, ועם ערך שלילי על טעות קטלנית.

השתמש ב-filan באופן מקוון באמצעות שירותי onworks.net