From da3b784b05406d66f42671ed84a4a02bb8e1381d Mon Sep 17 00:00:00 2001 From: alex Date: Sun, 6 Sep 2026 14:38:40 -0400 Subject: [PATCH] added quote-editting flag and functions --- client.go | 543 +++++++++++++++++++++++++++++++++++++----------------- server.go | 156 +++++++++++----- 2 files changed, 484 insertions(+), 215 deletions(-) diff --git a/client.go b/client.go index 874a4eb..89aaf04 100644 --- a/client.go +++ b/client.go @@ -1,7 +1,7 @@ // ============================================================================= // Auth: alex // File: client.go -// Revn: 01-09-2025 4.0 +// Revn: 09-06-2026 3.0.0 // Func: ask server for a message of the day quote // // TODO: remove ioutil import @@ -24,29 +24,39 @@ // imported check() from soary // 09-29-2023: commented handle() //*10-02-2023: commented main(), and friends -//*10-05-2023: /remove/ works +//#10-05-2023: /remove/ works // removed -d flag // commented // 06-12-2024: began added PWFT to /la/ // 06-13-2024: finished adding PWFT to /la/ // commented PWFT stuff // STARTED BYTE-BASED PWFT REWRITE -//*06-14-2024: finished byte-based PWFT rewrite +//#06-14-2024: finished byte-based PWFT rewrite // commented //*01-09-2025: basically just copy/pasted from /la/ into /r1/, /r2/ +// 06-21-2026: copied v and vv flags from server +// copied /edit/ switch case from /remove/ in main() +// pulled /sa/ and /qa/ into separate functions +// 09-03-2026: renamed in() -> inputNumber() +// copied in() and removed all logic +// added firstEdit() and secondEdit() and /e1/ and /e2/ +// 09-04-2026: rewrote in() with bufio instead of scanln +//#09-06-2026: fixed blank message error in secondEdit() +// comments // // ============================================================================= package main -import ( +import ( + "bufio" // NewReader, ReadString "io" // io.EOF "io/ioutil" // ReadFile "flag" // BoolVar, StringVar, Parse "fmt" // Println "math/rand" // NewSource, New, Intn, *rand.Rand "net" // ResolveTCPAddr, DialTCP, conn.Write,Read - "os" // Exit, Create + "os" // Exit, Create, Stdin "strconv" // Atoi, Itoa "strings" // Split "time" // Now, UnixNano @@ -85,20 +95,37 @@ func check( err error ) { // get user input func in( prompt string ) string { + // instantiate reader + reader := bufio.NewReader( os.Stdin ) fmt.Print( prompt ) // print user prompt - var input string // declare var to hold user input - fmt.Scanln( &input ) // get user input + // get user input, read until newline + input, _ := reader.ReadString( '\n' ) + // strip trailing newline before returning + return input[:len( input ) - 1] +} + + +// get user input, must be a number +func inputNumber( prompt string ) string { + // get user input + //input := in( prompt ) + fmt.Print( prompt ) + var input string + fmt.Scanln( &input ) + // try to convert to an int, discard results _, err := strconv.Atoi( input ) // if there was an error, user didn't input an int if err != nil { // warn user against this fmt.Println( "Input must be a number" ) - input = in( prompt ) // try to get user input again + // try to get user input again + //XXX input = in( prompt ) + fmt.Println( "err: ", err.Error() ) // this, like handle() calling handle(), seems like a super // bad idea, stack-wise... } - // once user has properly inputted a number, return string of num + // once user has properly inputted a number, return string of num return input } @@ -113,7 +140,7 @@ func seed() *rand.Rand { // get a random number -func draw() string { +func draw( qsize int ) string { rn := seed() // get a random seed r := rn.Intn( qsize ) // get a random number using seed // convert random number to ascii, because converting @@ -123,6 +150,273 @@ func draw() string { } +// respond to size answer +func sizeAnswer( subcom []string ) string { + // subcom should contain only a size + // convert to int, catch error + size, err := strconv.Atoi( subcom[0] ) + + if err != nil { // if int conversion failed ( for some reason ) + os.Exit( 1 ) // just quit + // TODO make exit codes unique, document them + } + + // draw a random number, add to quote request + return "qr@" + draw( size ) + +} + + +// receive quote, print +func quoteAnswer( subcom []string ) string { + fmt.Println( subcom[0] ) // whole-ass just print quote + return "te@success" // set transaction end message +} + + +// add answer +func addAnswer( subcom []string ) string { + + var resp string = "te@" + + // if server says add succeeded + if subcom[0] == "success" { + fmt.Println( "Add successful" ) // print success + resp = resp + "success" // set transaction end message + // if server says add failed + } else if subcom[0] == "error" { + fmt.Println( "Add failed" ) // print fail + resp = resp + "error" // set transaction end message + // unknown status message + } else { + // print unknown status + fmt.Println( "Unknown status code: " + subcom[0] ) + // TODO should this be unknown instead of error? + resp = resp + "error" // set transaction end message + } + return resp +} + + +// receive answer to list +func listAnswer( subcom []string ) string { + + var resp string + + if len( subcom ) > 1 { // multistage send condition + if subcom[0] == "X" { // final message + // TODO update + // read entire temp storage file as byte array + tfile, err := ioutil.ReadFile( "temp.q" ) + check( err ) // check read for errors + // cast file to string, concat with recv'd string + tstr := string( tfile ) + subcom[1] + // split concat over newlines, separating quotes + tlist := strings.Split( tstr, "\n" ) + // iterate over array, printing each quote + for p, v := range tlist { + fmt.Println( p + 1, "\t", v ) + } + // delete temp storage file + err = os.Remove( "temp.q" ) + check( err ) // check rm for errors + resp = "te@X" // successful response message + } else { // first or intermediate message + // open temp quote storage file, creating if + // necessary, with write-only permissions, in + // append mode, wr u perm, r g/w perm + f, err := os.OpenFile( "temp.q", os.O_WRONLY | os.O_APPEND | os.O_CREATE, 0644 ) + check( err ) // check file open for errors + // write received message to file, keeping track + // of bytes written + n, err := f.WriteString( subcom[1] ) + check( err ) // check file write for errors + // cast bytes already written field to int + b, err := strconv.Atoi( subcom[0] ) + check( err ) // check cast for errors + // add bytes just written to bytes already written, cast + // back to string, and append to response variable + resp = "lr@" + strconv.Itoa( b + n ) + } + } else { + // split recv'd message over \n, create quote list + quotes := strings.Split( subcom[0], "\n" ) + for p, v := range quotes { // iterate over quotes + // print num of quote, followed by that quote + fmt.Println( p + 1, "\t", v ) + } + resp = "te@success" // set transaction end message + } + return resp +} + + +// first round edit request +func firstEdit( subcom []string ) string { + + var resp string + + if len( subcom ) > 1 { // multistage send condition + if subcom[0] == "X" { // final message + // TODO update + // read entire temp storage file as byte array + tfile, err := ioutil.ReadFile( "temp.q" ) + check( err ) // check read for errors + // cast file to string, concat with recv'd string + tstr := string( tfile ) + subcom[1] + // split concat over newlines, separating quotes + tlist := strings.Split( tstr, "\n" ) + // iterate over array, printing each quote + for p, v := range tlist { + fmt.Println( p + 1, "\t", v ) + } + // delete temp storage file + err = os.Remove( "temp.q" ) + check( err ) // check rm for errors + // ask user which quote to remove + resp = "e2@" + inputNumber( "\n-> " ) + } else { // first or intermediate message + // open temp quote storage file, creating if + // necessary, with write-only permissions, in + // append mode, wr u perm, r g/w perm + f, err := os.OpenFile( "temp.q", os.O_WRONLY | os.O_APPEND | os.O_CREATE, 0644 ) + check( err ) // check file open for errors + // write received message to file, keeping track + // of bytes written + n, err := f.WriteString( subcom[1] ) + check( err ) // check file write for errors + // cast bytes already written field to int + b, err := strconv.Atoi( subcom[0] ) + check( err ) // check cast for errors + // add bytes just written to bytes already written, cast + // back to string, and append to response variable + resp = "e1@" + strconv.Itoa( b + n ) + } + } else { + // split recv'd message over \n, create quote list + quotes := strings.Split( subcom[0], "\n" ) + for p, v := range quotes { // iterate over quotes + // print num of quote, followed by that quote + fmt.Println( p + 1, "\t", v ) + } + // ask user which quote to edit + resp = "e2@" + inputNumber( "\n-> " ) + } + return resp +} + + +// second round edit request ( and also third, technically ) +func secondEdit( subcom []string ) string { + // success message and edit request pt2 come to the same place + if subcom[0] == "success" { + // print success and end transaction + fmt.Println( "Edit successful" ) + return "te@success" + } + + // edit command is a removal and an add + var resp string + resp = "cr@r2@" + subcom[0] + "@ar@" + // server response is text to be edited + fmt.Println( "as is: " + subcom[1] ) + fmt.Print( "preview: " ) // won't be useful until pretty print + _ = quoteAnswer( subcom[1:] ) // display quote properly + + // get user input for new quote and send + resp = resp + in( "\nupdate -> " ) + return resp +} + + +// list of all quotes, pick which to remove +func firstRemove( subcom []string ) string { + // the idea is that if the user doesn't specify which quote to + // remove, list all quotes and let the user choose the quote + // to remove. There was probably a way to handle this a little + // more simply, but this, I feel, has some nuance to it that I + // actually like + + var resp string + + if len( subcom ) > 1 { // multistage send condition + if subcom[0] == "X" { // final message + // TODO update + // read entire temp storage file as byte array + tfile, err := ioutil.ReadFile( "temp.q" ) + check( err ) // check read for errors + // cast file to string, concat with recv'd string + tstr := string( tfile ) + subcom[1] + // split concat over newlines, separating quotes + tlist := strings.Split( tstr, "\n" ) + // iterate over array, printing each quote + for p, v := range tlist { + fmt.Println( p + 1, "\t", v ) + } + // delete temp storage file + err = os.Remove( "temp.q" ) + check( err ) // check rm for errors + // ask user which quote to remove + resp = "r2@" + inputNumber( "\n-> " ) + } else { // first or intermediate message + // open temp quote storage file, creating if + // necessary, with write-only permissions, in + // append mode, wr u perm, r g/w perm + f, err := os.OpenFile( "temp.q", os.O_WRONLY | os.O_APPEND | os.O_CREATE, 0644 ) + check( err ) // check file open for errors + // write received message to file, keeping track + // of bytes written + n, err := f.WriteString( subcom[1] ) + check( err ) // check file write for errors + // cast bytes already written field to int + b, err := strconv.Atoi( subcom[0] ) + check( err ) // check cast for errors + // add bytes just written to bytes already written, cast + // back to string, and append to response variable + resp = "r1@" + strconv.Itoa( b + n ) + } + } else { + // split recv'd message over \n, create quote list + quotes := strings.Split( subcom[0], "\n" ) + for p, v := range quotes { // iterate over quotes + // print num of quote, followed by that quote + fmt.Println( p + 1, "\t", v ) + } + // ask user which quote to remove + resp = "r2@" + inputNumber( "\n-> " ) + } + return resp +} + + +// second remove, determine if success or failure +func secondRemove( subcom []string ) string { + var resp string + // if server says remove succeeded + if subcom[0] == "success" { + fmt.Println( "Remove successful\n" ) // success + // list all quotes to validate remove succeeded + // TODO should /aa/ also make /lr/ before /te/? + resp = "lr@init" // set transaction end message + } else if subcom[0] == "error" { // if server says remove failed + fmt.Println( "Remove failed" ) // print failure + resp = "te@error" // set transaction end message + } else { // if unknown status message + // TODO there's a known issue where if the buffer + // size ( -s ) is less than 10, on the server side, + // 'success' will get cut off ( r2@success ) + // and /r2/ will end up down here despite having + // actually worked correctly, and will not display the + // list, as it should on success + // print unknown status + fmt.Println( "Unknown error code: " + subcom[0] ) + // TODO should this be unknown instead of error? + resp = "te@error" // set transaction end message + } + return resp +} + + // get server response and print func handle( conn net.Conn ) { @@ -135,176 +429,37 @@ func handle( conn net.Conn ) { check( err ) // check for errors // split recv'd message over @, separate header from message - msg := strings.Split( string( buffer[:n] ), "@" ) + message := strings.Split( string( buffer[:n] ), "@" ) + command := message[0] var resp string // declare response variable - switch msg[0] { // switch/case over the header + switch command { // switch/case over the header // if message is... case "sa": // /sa/, size answer - // convert back half to int, catch error - size, nerr := strconv.Atoi( msg[1] ) - if nerr == nil { // if there was no error - qsize = size // set size global to recv'd size - } else { - // if int conversion failed, just quit - // TODO make more robust - os.Exit( 1 ) - } - req := draw() // draw a random number - resp = "qr@" + req // create quote query with rng - case "ba": // /ba/, bad answer - // TODO create server-side, and handle client-side - fmt.Println( "error in " + msg[1] + ": " + msg[2] ) - resp = "te@error" // set transaction end message + resp = sizeAnswer( message[1:] ) case "qa": // /qa/, quote answer - fmt.Println( msg[1] ) // whole-ass just print quote - resp = "te@success" // set transaction end message - case "la": // /la/, list answer - if len( msg ) > 2 { // multistage send condition - if msg[1] == "X" { // final message - // TODO update - // read entire temp storage file as byte array - tfile, err := ioutil.ReadFile( "temp.q" ) - check( err ) // check read for errors - // cast file to string, concat with recv'd string - tstr := string( tfile ) + msg[2] - // split concat over newlines, separating quotes - tlist := strings.Split( tstr, "\n" ) - // iterate over array, printing each quote - for p, v := range tlist { - fmt.Println( p + 1, "\t", v ) - } - // delete temp storage file - err = os.Remove( "temp.q" ) - check( err ) // check rm for errors - resp = "te@X" // successful response message - } else { // first or intermediate message - // open temp quote storage file, creating if - // necessary, with write-only permissions, in - // append mode, wr u perm, r g/w perm - f, err := os.OpenFile( "temp.q", os.O_WRONLY | os.O_APPEND | os.O_CREATE, 0644 ) - check( err ) // check file open for errors - // write received message to file, keeping track - // of bytes written - n, err = f.WriteString( msg[2] ) - check( err ) // check file write for errors - // cast bytes already written field to int - b, err := strconv.Atoi( msg[1] ) - check( err ) // check cast for errors - // add bytes just written to bytes already - // written, cast back to string, and append to - // response variable - resp = "lr@" + strconv.Itoa( b + n ) - } - } else { - // split recv'd message over \n, create quote list - quotes := strings.Split( msg[1], "\n" ) - for p, v := range quotes { // iterate over quotes - // print num of quote, followed by that quote - fmt.Println( p + 1, "\t", v ) - } - resp = "te@success" // set transaction end message - } + resp = quoteAnswer( message[1:] ) case "aa": // /aa/, add answer - // if server says add succeeded - if msg[1] == "success" { - fmt.Println( "Add successful" ) // print success - resp = "te@success" // set transaction end message - // if server says add failed - } else if msg[1] == "error" { - fmt.Println( "Add failed" ) // print fail - resp = "te@error" // set transaction end message - // unknown status message - } else { - // print unknown status - fmt.Println( "Unknown status code: " + msg[1] ) - // TODO should this be unknown instead of error? - resp = "te@error" // set transaction end message - } + resp = addAnswer( message[1:] ) + case "la": // /la/, list answer + resp = listAnswer( message[1:] ) + case "e1": // /e1/, edit quote ( first transaction ) + resp = firstEdit( message[1:] ) + case "e2": // /e2/, edit quote ( second transaction ) + resp = secondEdit( message[1:] ) case "r1": // /r1/, remove ( first transaction ) - // the idea is that if the user doesn't specify which quote to - // remove, list all quotes and let the user choose the quote - // to remove. There was probably a way to handle this a little - // more simply, but this, I feel, has some nuance to it that I - // actually like - // redo /r1/, list all quotes - // split recv'd message over newline to create quote list - if len( msg ) > 2 { // multistage send condition - if msg[1] == "X" { // final message - // TODO update - // read entire temp storage file as byte array - tfile, err := ioutil.ReadFile( "temp.q" ) - check( err ) // check read for errors - // cast file to string, concat with recv'd string - tstr := string( tfile ) + msg[2] - // split concat over newlines, separating quotes - tlist := strings.Split( tstr, "\n" ) - // iterate over array, printing each quote - for p, v := range tlist { - fmt.Println( p + 1, "\t", v ) - } - // delete temp storage file - err = os.Remove( "temp.q" ) - check( err ) // check rm for errors - // ask user which quote to remove - resp = "r2@" + in( "\n-> " ) - } else { // first or intermediate message - // open temp quote storage file, creating if - // necessary, with write-only permissions, in - // append mode, wr u perm, r g/w perm - f, err := os.OpenFile( "temp.q", os.O_WRONLY | os.O_APPEND | os.O_CREATE, 0644 ) - check( err ) // check file open for errors - // write received message to file, keeping track - // of bytes written - n, err = f.WriteString( msg[2] ) - check( err ) // check file write for errors - // cast bytes already written field to int - b, err := strconv.Atoi( msg[1] ) - check( err ) // check cast for errors - // add bytes just written to bytes already - // written, cast back to string, and append to - // response variable - resp = "r1@" + strconv.Itoa( b + n ) - } - } else { - // split recv'd message over \n, create quote list - quotes := strings.Split( msg[1], "\n" ) - for p, v := range quotes { // iterate over quotes - // print num of quote, followed by that quote - fmt.Println( p + 1, "\t", v ) - } - // ask user which quote to remove - resp = "r2@" + in( "\n-> " ) - } + resp = firstRemove( message[1:] ) case "r2": // /r2/, remove ( second transaction ) - // if server says remove succeeded - if msg[1] == "success" { - fmt.Println( "Remove successful\n" ) // success - // list all quotes to validate remove succeeded - // TODO should /aa/ also make /lr/ before /te/? - resp = "lr@init" // set transaction end message - // if server says remove failed - } else if msg[1] == "error" { - fmt.Println( "Remove failed" ) // print failure - resp = "te@error" // set transaction end message - // if unknown status message - } else { - // TODO there's a known issue where if the buffer - // size ( -s ) is less than 10, on the server side, - // 'success' will get cut off ( r2@success ) - // and /r2/ will end up down here despite having - // actually worked correctly, and with not display the - // list, as it should on success - // print unknown status - fmt.Println( "Unknown error code: " + msg[1] ) - // TODO should this be unknown instead of error? - resp = "te@error" // set transaction end message - } + resp = secondRemove( message[1:] ) case "br": // /br/, bad request // client has asked for something nonsensical // TODO write out to file fmt.Println( "Client sent a bad request" ) resp = "te@error" // set transaction end message + case "ba": // /ba/, bad answer + // TODO create server-side, and handle client-side + fmt.Println( "error in " + message[1] + ": " + message[2] ) + resp = "te@error" // set transaction end message default: // something undefined entirely // TODO write out to file //fmt.Println( "Message header not recognized" ) @@ -322,7 +477,7 @@ func handle( conn net.Conn ) { // globals -var qsize int // keep track of num of quotes +//var qsize int // keep track of num of quotes var conn net.Conn // keep track of connection @@ -330,18 +485,40 @@ var conn net.Conn // keep track of connection var add bool // add new quotes to quote file ( on server ) var remove bool // remove quotes from quote file ( on server ) var list bool // request entire quote file from server +var edit bool // edit a pre-existing quote from quote file ( on server ) var dest string // provide a new destination ip and port var tsize int // size of transmission buffer +var VERS string // version func main() { + var v bool // version flag + var vv bool // big version flag + // define flags - flag.BoolVar( &add, "a", false, "add quote to list" ) + flag.BoolVar( &add, "a", false, "add quote to list" ) flag.BoolVar( &remove, "r", false, "remove quote from list" ) - flag.BoolVar( &list, "l", false, "print quote list" ) + flag.BoolVar( &list, "l", false, "print quote list" ) + flag.BoolVar( &edit, "e", false, "edit quote from list" ) flag.StringVar( &dest, "ip", "127.0.0.1:1300", "ip:port of server" ) - flag.IntVar( &tsize, "s", 256, "transmission size ( bytes )" ) - flag.Parse() // process flags + flag.IntVar( &tsize, "s", 256, "transmission size ( bytes )" ) + flag.BoolVar( &v, "v", false, "display version and exit" ) + flag.BoolVar( &vv, "vv", false, "display version and about info and exit" ) + flag.Parse() + + // FIXME get better versioning method + VERS = "3.0.0" + + if vv { // display info and exit + fmt.Println( "ekho client v" + VERS ) + fmt.Println( "ekho is named after Echo the Oread" ) + fmt.Println( "in Greek mythology, Echo was cursed by Hera to only be able to say the last words spoken to her" ) + fmt.Println( "i found this to be quite fitting for a MOTD server" ) + return + } else if v { // display info and exit + fmt.Println( VERS ) + return + } service := dest // declare server ip:port @@ -375,6 +552,27 @@ func main() { fmt.Println( "/a/ flag must be used with an arugment" ) os.Exit( 1 ) } + case edit: // if edit flag is active + // if arguments were specified + if len( flag.Args() ) > 0 { + // argument is supposed to the number of the quote to + // be edited, get first arg + // cast to int just to make sure it's a valid number + // assuming the user knows what they're doing + _, rerr := strconv.Atoi( flag.Args()[0] ) + // if there was an error, just pretend there's no args + if rerr != nil { + command = "e1@init" // remove request 1 + } else { + // if user knows the number, take care of it + // arg[0] is a string, so concat is cool + // jump right into edit request 2 + command = "e2@" + flag.Args()[0] + } + } else { // if no argument was specified for edit + // jump right into edit request 1 + command = "e1@init" + } case remove: // if remove flag is active // if arguments were specified if len( flag.Args() ) > 0 { @@ -386,7 +584,6 @@ func main() { // if there was an error, just pretend there's no args if rerr != nil { command = "r1@init" // remove request 1 - // TODO come up w/ useful argument, replace dumvar } else { // if user knows the number, take care of it // arg[0] is a string, so concat is cool diff --git a/server.go b/server.go index 72b437e..10bc67b 100644 --- a/server.go +++ b/server.go @@ -1,10 +1,10 @@ // ============================================================================= // Auth: alex // File: server.go -// Revn: 05-12-2026 2.1.2 +// Revn: 09-06-2026 3.0.0 // Func: host MOTD connection // -// TODO: +// TODO: FUCK // add user-specific prints // write usage and errors to logfile // remove ioutil import @@ -51,6 +51,8 @@ // line bug in /la/ AGAIN // 05-11-2026: updated fread() to handle users in qfile // 05-12-2026: added v and vv input flags +// 09-05-2026: buncha shit happened, dropped the commit +//#09-06-2026: added /e1/, /e2/, and /cr/, got edit working // // ============================================================================= @@ -121,14 +123,9 @@ func fread() string { // bugs where a blank item was introduced into qlist and calling // /la/ would produce a blank line on the client side that didn't // really exist - qfile = qfile[:len( qfile ) - 1] + qfile = qfile[:len( qfile )] // cast bytes to string, split string over newline into array - //qlist = strings.Split( string( qfile ), "\n" ) - profiles := strings.Split( string( qfile ), "@" ) - for _, p := range profiles { - quotes := strings.Split( p, ":" ) - qlist[quotes[0]] = strings.Split( quotes[1], "\n" ) - } + qlist = strings.Split( string( qfile ), "\n" ) return string( qfile ) // return file as string } @@ -145,9 +142,9 @@ func writeFile( f string ) { } -// handle connections ( new and improved ) -func handle( conn net.Conn ) { - +// receive from connection, send to get processed, send out response +func receive( conn net.Conn ) { + // create buffer to hold read message buffer := make( []byte, tsize ) //var buffer [256]byte @@ -169,6 +166,24 @@ func handle( conn net.Conn ) { // cast message to string, take first n bytes, split over @ command := strings.Split( string( buffer[:n] ), "@" ) + if command[0] == "te" { + conn.Close() + return + } + + resp := handle( command ) + + // write response to client + _, err = conn.Write( []byte( resp ) ) + checkN( err, conn ) // make sure write worked + + receive( conn ) // call handle() again to get response from client +} + + +// handle connections ( new and improved ) +func handle( command []string ) string { + // declare response string var resp string switch command[0] { // switch/case over opcode @@ -179,20 +194,9 @@ func handle( conn net.Conn ) { // concat and send resp = "sa@" + num // size answer case "qr": // /qr/, quote request - // see if user was sent - subcommands := strings.Split( command[1], ":" ) - - // keep track of name, or default if need be - var name string - if len( subcommands ) == 1 { - name = "default" - } else { - name = subcommands[1] - } - // convert message argument to string to make sure it's a // valid number - num, nerr := strconv.Atoi( subcommands[0] ) + num, nerr := strconv.Atoi( command[0] ) // nerr will not be nil if comm[1] is not a number if nerr != nil { // formulate an error message @@ -200,7 +204,7 @@ func handle( conn net.Conn ) { resp = "ba@qr@!" // bad answer } else { // comm[1] was a number, but... switch { // how do we know it's a valid number - case num > len( qlist[name] ): + case num > len( qlist ): // bad answer in quote request resp = "ba@qr@>" // why bad? num is > @@ -210,7 +214,7 @@ func handle( conn net.Conn ) { // why bad? num is - default: // good num, get quote, send off - resp = "qa@" + qlist[name][num] // quote answer + resp = "qa@" + qlist[num - 1] // quote answer } } case "lr": // /lr/, list request @@ -252,11 +256,83 @@ func handle( conn net.Conn ) { } case "ar": // /ar/, add request // append new quote to list - qlist["f"] = append( qlist["f"], command[1] ) + qlist = append( qlist, command[1] ) // also append new quote to file variable qfile = qfile + "\n" + command[1] writeFile( qfile ) resp = "aa@success" // add answer + case "cr": + if len( command ) != 5 { + return "ba@bad request" + } + + //mes1 := strings.Join( command[1:3], "@" ) + //mes1 := strings.Join( command[3:], "@" ) + _ = handle( command[1:3] ) + _ = handle( command[3:] ) + + resp = "e2@success" + case "e1": + resp = "e1@" // begin crafting response + // file too big for single transmission + // initial header size is 5, e1@1@, so counting that into + // the transmission size, the file must be longer than 251 + // ( default ) bytes to reach this block of code + if len( qfile ) > ( tsize - 5 ) { + if command[1] == "init" { // first request + // add message number, delim, and the first + // transmittable bytes + resp = resp + "0@" + qfile[:( tsize - 5 )] + } else { // subsequent requests + // convert byte count to int + bytes, err := strconv.Atoi( command[1] ) + check( err ) // make sure convert worked + // replace tx'd bytes and delim to new header + resp = resp + command[1] + "@" + rlen := len( resp ) // capture header length + // slices are always of size "txsize - header + // length", so find end byte + end := bytes + ( tsize - rlen ) + // if end goes beyond the bounds of the list + if end > len( qfile ) { + // replace byte count with X to signal + // final message, concat the rest of the file, + // beginning with the start index + resp = "e1@X@" + qfile[bytes:] + } else { + // get slice from start index to end, concat + // with response + resp = resp + qfile[bytes:end] + } + } + } else { // file is smaller than the tx size + // just concat entire list to send + resp = resp + qfile // list answer + } + case "e2": + // convert message argument to string to make sure it's a + // valid number + num, nerr := strconv.Atoi( command[1] ) + // nerr will not be nil if comm[1] is not a number + if nerr != nil { + // formulate an error message + // TODO flesh this out more + resp = "ba@qr@!" // bad answer + } else { // comm[1] was a number, but... + switch { // how do we know it's a valid number + case num > len( qlist ): + // bad answer in quote request + resp = "ba@qr@>" + // why bad? num is > + case num < 0: + // bad answer in quote request + resp = "ba@qr@-" + // why bad? num is - + default: + // good num, get quote, send off + resp = "e2@" + command[1] + "@" + qlist[num - 1] + } + } case "r1": // /r1/, remove request 1 resp = "r1@" // begin crafting response // file too big for single transmission @@ -319,14 +395,14 @@ func handle( conn net.Conn ) { default: // replace the quote at that position with // final quote - qlist["f"][num] = qlist["f"][len( qlist ) - 1] + qlist[num] = qlist[len( qlist ) - 1] // remove second copy of quote - qlist["f"] = qlist["f"][:len( qlist ) - 1] + qlist = qlist[:len( qlist ) - 1] // O(1) remove from list at any position // must entirely recreate quote string var f string = "" // init empty string // iterate over list, disregard index - for _, v := range qlist["f"] { + for _, v := range qlist { // add next quote to file and separate // quotes with newline f = f + v + "\n" @@ -349,25 +425,21 @@ func handle( conn net.Conn ) { case "te": // /te/, transaction end // TODO should I be sending something? // TODO is it better to close now or outside of handle() - conn.Close() // close connection and leave - return // return from handle(), finish connection + //conn.Close() // close connection and leave + return "" // return from handle(), finish connection default: // opcode not recognized // TODO there should be more being down, here, right? - return // return from handle(), finish connection + return "" // return from handle(), finish connection } - // write response to client - _, err = conn.Write( []byte( resp ) ) - checkN( err, conn ) // make sure write worked - - handle( conn ) // call handle() again to get response from client + return resp } // globals -//var qlist []string // list of quotes -var qlist = make( map[string][]string ) +var qlist []string // list of quotes +//var qlist = make( map[string][]string ) var qfile string // file object var tsize int // size of transmission buffer var VERS string // version @@ -391,7 +463,7 @@ func main() { flag.Parse() // FIXME get better versioning method - VERS = "2.1.2" + VERS = "3.0.0" if vv { // display info and exit fmt.Println( "ekho server v" + VERS ) @@ -427,7 +499,7 @@ func main() { // wait, create connection when found conn, err := listener.Accept() check( err ) // make sure connection works - go handle( conn ) // handle connection + go receive( conn ) // handle connection } }