Thanks for the answer! (:
In python it was straightforward to implement and it works like a charm. It
sends small packets with delay between each other without even care if it
is UDP or TCP:
[image: prooff.png]
[image: proof2.png]
The connection ( if UDP/ TCP ) is handled independently, the sending part
( the one I pasted ) is equal for both of them, its just an "if" in the
code.
The server ( which I control ) does riassembling by himself, so its fine.
I know that providing a solution is not an easy task, I know it for sure.
I'm just looking for a pro ( a saint ahaha ) with some patience that
provides an example of code of how it should look like to work as I wish it
does.
I do not expect do make it work in first place, its almost impossible, but
we all know, with some errors you get the solution before or after(:
In this case I don't really know where to start and how to do it ( im a
newbie in golang ), so I came here to ask help
Il giorno martedì 29 giugno 2021 alle 14:22:32 UTC+2 Brian Candler ha
scritto:
> What sort of socket - TCP or UDP? TCP is an infinite stream, and there is
> no reliable way to divide it into "chunks" (except possibly using the URG
> pointer, which is very rarely used). There is no guarantee that waiting
> 1.6 seconds between sends will actually send in separate segments being
> sent, nor that the receiver will be able to determine that these were
> separate segments - they may well be merged.
>
> To do it reliably, you'd want to add your own framing, e.g. send an 4-byte
> length followed by that number of bytes.
>
> If you show a *complete* go program, together with a description of how it
> isn't working to your satisfaction, then maybe someone can help you fix
> it. If you want to make it behave the same as some given python program,
> then maybe you should show the python program as well.
>
> On Tuesday, 29 June 2021 at 11:51:57 UTC+1 LetGo wrote:
>
>> I forgot this:
>> // Manage connection for different behavior
>> func handleConn(conn net.Conn, binPath string) {
>>
>> msg := "Status?\n"
>>
>> if binPath != "" {
>> // Execute command and send Standard I/O net.Conn
>> cmd := exec.Command(binPath)
>> cmd.Stdin = conn
>> cmd.Stdout = conn
>> cmd.Stderr = conn
>> cmd.Run()
>> fmt.Println("Disconnected!?")
>> time.Sleep(5 * time.Second)
>> pippo, err2 := conn.Write([]byte(msg))
>> if err2 != nil {
>> fmt.Println(pippo)
>> }
>>
>>
>>
>>
>> } else {
>> // Copy Standard I/O in a net.Conn
>> go io.Copy(os.Stderr, conn)
>> go io.Copy(os.Stdout, conn)
>> io.Copy(conn, os.Stdin)
>>
>> }
>> }
>>
>> Il giorno martedì 29 giugno 2021 alle 12:27:00 UTC+2 LetGo ha scritto:
>>
>>> I have a proxy written in python with some logic that I would like to
>>> implement in a golang tool of mine, but I don't really know how to do it.
>>> It splits the data sent via socket (stdout) in small chunks, with a
>>> delay between each other
>>>
>>> I have a variable which gets a random number from a list:
>>> ....
>>> listbytes = [87, 88, 89, 90]
>>> ....
>>>
>>> I have also a function which splits in small chunk of bytes(n) the
>>> data(lst):
>>>
>>> ............
>>>
>>> def chunks(lst, n):
>>>
>>> "Yield successive chunks from lst, where n is a list of possible
>>> sizes"
>>>
>>> i = 0
>>>
>>> while i < len(lst):
>>>
>>> k = min(random.choice(n), len(lst) - i)
>>>
>>> yield lst[i:i + k]
>>>
>>> i += k
>>> .............
>>>
>>> Both things are executed this way:
>>> ...
>>> # get the data
>>> data = s.recv(BUFFER_SIZE)
>>>
>>> if s == s_src:
>>> d = LOCAL_DATA_HANDLER(data)
>>> for chunk in chunks(d, listbytes):
>>> #sleep 1.6 seconds before sending the next chunk of data
>>> time.sleep(1.6)
>>> #send the chunked data
>>> s_dst.send(bytes(chunk) )
>>> ...
>>>
>>>
>>> How do I implement *the same exact logic* illustrated here?
>>>
>>> func (nObj NetObject) RunClient(cmd string) {
>>> // Try connection
>>>
>>> for {
>>> conn, err := net.Dial(nObj.Type, nObj.Service)
>>> fmt.Print("connect")
>>> // msg := "status"
>>> if err != nil {
>>> fmt.Println("fail")
>>> }
>>> if err == nil {
>>> fmt.Println("ok")
>>> // defer conn.Close()
>>> defer conn.Close()
>>> log.Println("Connected to", conn.RemoteAddr())
>>> handleConn(conn, cmd)
>>>
>>>
>>> //handleConn(conn, cmd)
>>> fmt.Println("After handle")
>>> }
>>> fmt.Println("Before sleep")
>>> time.Sleep(5 * time.Second)
>>> }
>>>
>>> }
>>> Can you help me please?
>>>
>>
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/golang-nuts/f82a73ad-164e-4af5-b183-9d4bf0b54911n%40googlegroups.com.
