Wie kann man mehr als 256 Zeichen in expect eingeben?

byron1778 · 8 Mai 2008

Hallo Forum,

ich arbeite mit dem Tool Expect.
Bei diesem gibt es aber das Problem, das es nicht mehr als 256 Zeichen zur Eingabe zulaesst.
Das duerfte mit der .ksh zusammenhaengen, weil expect vll. diese Shell verwendet.

Weiss jemand vll., ob es in expect eine Option gibt, die es verhindert nur 256 Zeichen einzugeben?
oder dass man expect verbietet mit der .ksh zu arbeiten ( falls es wirklich diese Shell verwendet? )

Danke Euch vielmals fuer jede Hilfe!

mfG

Anonymous · 8 Mai 2008

Kanst du das mal am genauem Beispiel hier angeben. eventuell machst du da irgend was falsch. Habe früher viel damit gearbeitet, doch das Problem hat sich nie gestellt.

robi

byron1778 · 8 Mai 2008

Nun ja das Problem ist wie folgt.

Ich rufe das Program xxx auf, welches mit expect geschrieben wurde.
Jetzt verlangt er eine Eingabe und diese Eingabe ist laenger als 256 Zeichen, ca. um die 1000 Zeichen herum.
Nur leider nimmt er nur die ersten 256 Zeichen dieser Message.

So sieht das Programm aus ( leider etwas viel ... )

Code:

#!/opt/sfw/bin/expect
# use -d option to debug
###########################################################################################
#
#                               ORC PROTOCOL COMMANDLINE
#
###########################################################################################
#
# Script written in Expect to simulate a CommandLine Interface to the Orc Protocol
# Can be used to check Messages
#
#
# Each Message will be automatically prefixed by it's length(+2 for Unix)
#
# Example:
#
# {message_info={message_type=login}|login_id=xxx|password=xxx}
# is expanded to:
# "0000000074{message_info={message_type=login}|login_id=xxx|password=xxx}"
#
###########################################################################################
#
#                               Variables
#
###########################################################################################
#
set op_port xxx
set api_user "xxx"
set api_pwd "xxx"
#
#
###########################################################################################
#
#                               Functions
#
###########################################################################################

proc check_listen {cline} {
#first time no need to send xtra linefeed
set LFsent 1
if {$cline==""} {
# go into Listen
        send_user "Listening ...\n"
        set instring ""
        while {1} {
# dont display op message in raw format as received by telnet
                log_user 0
# get already there message(s) up to last waved close bracket till buffer end
                expect -timeout 1  -re "(.*\})" {
# read complete buffer
                        set instring $expect_out(buffer)
# enable direct display again
                        log_user 1
#remove all previous Linefeeds
                        regsub -all "\n" $instring "" instring
# Put Line Feed between all waved close brackes and 0 behind
                        regsub -all "\}0" $instring "\}\n0" instring
#if single message output Linefeed
                        send_user "$instring"
#linefeed not yet sent
                        set LFsent 0
                         } timeout {
#timeout after instring not equal ""  means last message is complete, so  send Linefeed
                                if { $instring !="" } {
                                         send_user "\n"
                                         set LFsent 1
                                         }
                                set instring ""
                        } eof {send_op_error}
                        expect_user -timeout 0 -re "(.*\n)" { return 1 }
                }
        }
return 0
}

###########################################################################################

proc send_to_orc {cmdline} {
#telnet_spawn_id is used globally
global telnet_spawn_id
# Calc Length of CommandLine
set number ""
set number [format "%010d" [expr [string length $cmdline]+2]]
if {[expr [string length $cmdline]]>0} {
# Send Command to Telnet Session
# A LINE FEED at Line End ist MOST important, otherweise ORC will not get the Input!!!
        send "$number$cmdline\n"
        send_user "\n"
# Increase Buffer for Larger Results
#               match_max -d 100000
#               set mm [expr [match_max]]
#               send_user "matchmax $mm\n"
#               stty raw
# Read Response
# First read your own just sent Message echoed by Telnet
# plus the Response received so far
        expect -re "(.*\n)"
# Wait for (Rest) of Response
#       sleep 0.5
# 2nd time read rest of Response, which comes without LineFeed
# use a waved bracket as significant character of OP Message
set instring ""
#set count 0
while {1} {
        log_user 0
        if {$instring==""} {
        expect -timeout 15 -re "(.*\})" {
        set instring $expect_out(buffer)} eof {send_op_error}
        } else {
         expect -timeout 1 -re "(.*\})" {
        set instring $expect_out(buffer)} timeout {
        break } eof {
#               close -i $telnet_spawn_id
# if user already logged on in 2nd session, this session would close
# restart session immediately by calling open_telnet
# gets new spawn_id
                set telnet_spawn_id [open_telnet]
                 break }
        }
# Put Line Feed between all waved close brackes and 0 behind
        log_user 1
                        regsub -all "\}0" $instring "\}\n0" instring
#                       incr count
#                       send_user "Count "
#                       send_user $count
#                       send_user "\n"
                        send_user "$instring"
}
# Newline after Response
#               stty -raw
        send_user "\n\n"
        }
}

###########################################################################################

proc init_buffer {} {
global expect_out
#global telnet_spawn_id
# Flush all - init
        set expect_out(buffer) ""
        set expect_out(1,string) ""
        expect *
# Turn on Display
        log_user 1
}

###########################################################################################

proc send_op_error {} {
global op_port
        send_user "\nORC PROTOCOL on Port $op_port is NOT running!\nExiting\n"
        exit
}

###########################################################################################

proc open_telnet {} {
global op_port
global telnet_spawn_id
#
#match_max -d 100000
#
# Open Telnet Connection
spawn -noecho telnet localhost $op_port

#
# Remember Spawn ID
set telnet_spawn_id $spawn_id
#
# Dont Display Telnet Prompt
log_user 0
#
sleep 1
# FlushRead telnet prompt info
expect -timeout 15 unreachable {
        send_op_error
        } -re "(.*)\n" { set telprompt $expect_out(1,string) }
return $spawn_id
}


###########################################################################################
#
#
#                               Start of Main
#
#
###########################################################################################
#
match_max 10000
send_user "\nORC PROTOCOL COMMANDLINE to check OP Messages\n\n"
send_user "Enter Messages - Length is calculated automatically - Exit with ^C\n"
send_user "Get Reply Messages from ORC\n"
send_user "Press ENTER for Listening\n"
#
###########################################################################################
#
#                               Open Telnet Session
#
###########################################################################################
#
open_telnet
#
###########################################################################################
#
#                       Beim Starten Auto Login mit API User
#
###########################################################################################
#
set startcommand "{message_info={message_type=login}|login_id=$api_user|password=$api_pwd}"
init_buffer
set spawn_id $telnet_spawn_id
send_to_orc "$startcommand"
#
###########################################################################################
#
#                               Main Loop
#
###########################################################################################

while {1} {
# if spawn_id changes because of internal restart of telnet session
# we need to set spawn_id correctly again
        set spawn_id $telnet_spawn_id
        init_buffer
        set commandline ""
# Send Command Prompt
        send_user "\nCommand:"
# Wait for User Input
        expect_user -timeout -1 -re "(.*)\n"
# Get CommandLine from User
        set commandline $expect_out(1,string)
        if {![check_listen "$commandline"]} {
                set spawn_id $telnet_spawn_id
                send_to_orc "$commandline"
        }
}
# Close Telnet Session
close -i $telnet_spawn_id

Uebergibt man ihm nun diese Message, dann akzeptiert es nur 256 Zeichen, die Console ( ich vermute hiermit die ksh ) gibt einfach nicht mehr her.
Habe auch schon versucht die Console vorher auf Bash umzuschalten, aber expect duerfte immer in ksh laufen ( aber da bin ich mir nicht so sicher ).

Anonymous · 8 Mai 2008

Was für ein Betriebssystem verwendest du ? Die erste Zeile im Script zeigt, dass es entweder keine Standardinstallation Suse ist oder du eventuell auch expect selbst kopiliert hast oder von einer anderen Installationsquelle bezogen hast.

Hab das heute im Laufe des Tages mal auf Solaris probiert, da funktioniert komischerweise die Bufferung des stdin bei deinem Script gar nicht. Allerdings andere Symtome als du hier beschrieben hast.

Um dem auf die Spur zu kommen habe ich das Script jetzt auf Suse 10.2 probiert und siehe da. über 1100 Zeichen sind gar kein Problem.

robi

PS : das nächst Mal bitte etwas aufpassen, IP-Adressen, Passwörter im Klartext oder auch verschlüsselt, Usernamen und ähnliches in Scripten bitte vor dem Posten ************* . Das hilft bösen Überraschungen aus dem Weg zu gehen.

byron1778 · 8 Mai 2008

Ich verwende Solaris 10 auf Sparc.
Sobald ich das Script aufrufe funktionieren nicht mehr als 256 Zeichen bei mir.
Seltsam, dass bei Dir andere Fehler aufscheinen ...

Danke für den Tipp mit den Usernamen und PW.
Ich werde es für das nächste Mal beachten !

Anonymous · 8 Mai 2008

ich hatte Solaris 8 Sparc, (expect selbst kompiliert) und bei mir waren es immer eine unbestimmte Anzahl, jedoch maximal 60, der letzen Zeichen als das Ergebniss.

robi

Geier0815 · 8 Mai 2008

Hast Du es denn inzwischen per edit geändert? Wenn nicht: nachholen, wer weiß wer den Thread irgendwann mal ausgräbt!

byron1778 · 8 Mai 2008

Dann wird mir vll. nichts anderes übrig bleiben als es zu kompilieren.
Im Internet selber habe ich gelesen, dass es allerdings bekannt ist das Problem mit den 256 Zeichen und man es verhindern kann indem man etwas herumtrickst.
Wie ist jetzt leider nicht ganz genau gestanden, ich glaube aber indem man <enter> drückt und die Newline versucht zu ignorieren.

Nur dachte ich mir, dass es doch auch einfacher gehen muss, als sich irgendwelche Kunstgriffe einfallen zu lassen.

Wie kann man mehr als 256 Zeichen in expect eingeben?

byron1778

Hacker

Anonymous

Gast

byron1778

Hacker

Anonymous

Gast

byron1778

Hacker

Anonymous

Gast

Geier0815

Guru

byron1778

Hacker