moved to new name

hello this blog will be moved to

zombiecoding.blogspot.com

HACKING: disable security

for testing some security stuff aka buffer overflows, you must disable security such as address randomization and stack execuation deactivation.

simple as root do:

echo "0" > /proc/sys/kernel/randomize_va_space
echo "0" > /proc/sys/kernel/exec-shield
echo "0" > /proc/sys/kernel/exec-shield-randomize


next you must compile the application without stack execution dissable and stack protection for example. example for a gcc compilation flags (that help me to learn hacking):

gcc -m32 -w -fno-pie -z norelro -fno-stack-protector -ggdb -z execstack -o myprog myprog.c


see my last article (the same stuff, but older)

http://raycompstuff.blogspot.com/2010/09/hacks-tutorial-zero.html

have fun

CMD: import

schnell ein Screenshot von einem Fenster erstellen.

import bild.png

dann den Bereich mit Maus markieren, voila

OneStroke One Stroke

Meine Schwester beschaeftigt sich mit One Stroke, OneStroke

ist eine Maltechnik, hier mache ich kleine Werbung auf ihre Homepage

onestrokegermany

one stroke germany

A Letter from Anonymous

"Those who deny freedom to others deserve it not for themselves."
- Abraham Lincoln

"He who sacrifices freedom for security deserves neither."
– Benjamin Franklin

Hello World. We are Anonymous. What you do or do not know about us is irrelevant. We have decided to write to you, the media, and all citizens of the free world at large to inform you of the message, our intentions, potential targets, and our ongoing peaceful campaign for freedom.

"True, This! —
Beneath the rule of men entirely great,
The pen is mightier than the sword. Behold
The arch-enchanters wand! — itself a nothing! —
But taking sorcery from the master-hand
To paralyse the Cæsars, and to strike
The loud earth breathless! — Take away the sword —
States can be saved without it!"

- The Cardinal
Richelieu; Or the Conspiracy by: Edward Bulwer-Lytton

The message is simple: Freedom of Speech. Anonymous is peacefully campaigning for Freedom of Speech everywhere in all forms. Freedom of Speech for: The Internet, for journalism and journalists, and citizens of the world at large. Regardless of what you think or have to say; Anonymous is campaigning for you.
The recent news of our campaigns has been, at best, misinformed. Anonymous is not always the same group of people. The Constitution of the United States is said to be a living document, because it can be edited, amended; changed at the will of the people to suit the peoples' needs. In that same vein, Anonymous is a living idea. Anonymous is an idea that can be edited, updated, remanded, changed on a whim. We are living consciousness. We are not a terrorist organization as governments, demagogues, and the media would have you believe. At this time Anonymous is a consciousness focused on campaigning peacefully for Freedom of Speech. We ask the world to support us, not for our sake, but for your own. When governments control freedom they control you. The Internet is the last bastion of freedom in this evolving technical world. The Internet is capable of connecting us all. When we are connected we are strong. When we are strong we have power. When we have power we are able to do the impossible. This is why the government is moving on Wikileaks. This is what they fear. They fear our power when we unite. Do not forget this.

"...Now, we must all fear evil men. But there is another kind of evil which we must fear most, and that is the indifference of good men."
- Monsignor, Boondock Saints

Anonymous' intentions are very clear. We are not vigilantes, regardless of the sentiment of quoting Boondock Saints, we are people on a campaign for freedom. Anonymous' intentions are to change the current way the governments of the world and the people view true Freedom of Speech and The Internet. Anonymous is willing, ready, and able to campaign for the freedom for all. We are campaigning right now as you read the news, watch the television, fight with your
significant other, love your children, hate your neighbor, criticize the man or woman next to you. We are campaigning. The goal is simple: Win the right to keep the Internet free of any control from any entity, corporation, or government. We will do this until our, proverbial, dying breath. We do this not only for our selves, but for the world and its people at large.

"Truth is treason in the empire of lies."
- Ron Paul

Pay attention citizens, governments, and the world. Anonymous' peaceful campaign will focus on any organization, corporation, government, or entity until the Internet is truly free.
Anonymous is doing what many successful campaigns have done in the past; a sit-in. It may be hard to comprehend, but a digital sit-in is our most effective method to show that all of us deserve Freedom of Speech and a free Internet. Our methods may appear, on the outside, to be cruel to those the entities that we are campaigning against, but remember buy supporting censorship they are denying everyone a basic human right. Any person, corporation, government, or miscellaneous entity that stops supporting censorship and starts promoting Freedom of Speech and a free Internet will become our allies. Anonymous, at this time, wants to persuade our counterparts rather than hurt them. We are campaigning for freedom for everyone, even the opposing side.
Do not fear us. Anonymous' campaign does not intend to harm the individual citizen, any organizations, any websites, or government, that supports true freedom of speech. Anonymous' past is not our present. We are here for all of you; to campaign for all of you. Where others have made this promise and failed; we make this promise and aim to keep it for everyone.
Anything attributed, credited, or tagged to Anonymous is not always what we do. We arenot always the same consciousness on a yearly, monthly, or even hourly basis. Do not believe everything you hear or read on the news. Anonymous is often credited with actions that are not campaigned for by Anonymous. The true core of Anonymous is here to help the free world for now. Anonymous wishes to represent the truth and ask that you as a citizen, media organization, or government do the same.

GO BASE64: small stdin to stdout copy

package main

import (
  "encoding/base64";
  "io";
  "os";
)

func main() {
    e := base64.NewEncoder(base64.StdEncoding, os.Stdout)
    io.Copy(e, os.Stdin)
    e.Close()
}

Go: GoClipse

GoClipse is an Eclipse plugin that adds IDE functionality to the Eclipse platform for the Go programming language. The purpose of GoClipse is to create an environment in which development of Go is easy for a beginner and has enough rich features to be attractive to an expert.

GoClipse

TOOLS: interesting tools

THC-RUT

is a tool for monitoring networks. It offers a wide range of network discovery utilities like arp lookup on an IP range, spoofed DHCP request, RARP, BOOTP, ICMP-ping, ICMP address mask request, OS fingerprinting, high-speed host discovery, ...

thcrut arp 10.10.10.1-10.10.10.20

scan a network with arp-discovery.


ArpAlert

is a discovery tool for unauthorized request on MAC address. Some more info manpage


SendIP

a packet generator (IPv4, IPv6, NTP, BGP, RIP, TCP, UDP, ICMP, ...). Some complex, but very usefull packet genrator (see manpage)
Attention: the order of parameter is important to build correct packet ;)


Tor

is an anonymous proxy. Tor is a network of virtual tunnels that allows people and groups to improve their privacy and security on the Internet. It also enables software developers to create new communication tools with built-in privacy features. Tor provides the foundation for a range of applications that allow organizations and individuals to share information over public networks without compromising their privacy.


Knock

knockd is a port-knock server. It listens to all traffic on an ethernet (or PPP) interface, looking for special "knock" sequences of port-hits. A client makes these port-hits by sending a TCP (or UDP) packet to a port on the server. This port need not be open -- since knockd listens at the link-layer level, it sees all traffic even if it's destined for a closed port. When the server detects a specific sequence of port-hits, it runs a command defined in its configuration file. This can be used to open up holes in a firewall for quick access.

Qualitätskriterien für eine Theorie.

Eleganz: Ein Modell sollte so möglich wie einfach sein.

Sparsamkeit: nur wenig willkürliche Elemente enthalten (nur die sich an Beobachtung anpassen)

Erklärungskraft: Daten und Beobachtungen sollten übereinstimmen und verständlich sein.

Vorhersagefähigkeit: Beobachtungen vorhersagen können.

Das letzte trifft zurzeit nicht auf String Theorie. Aber abwarten.

HACKS: Tutorial Zero

The problem nowadays to learn buffer overflow is:
- linux kernel has protection (va_randomize, exec_shield,...)
- distribution has protection (armor, selinux, ...)
- gcc has protection (stack canary, ...

That is good, because it protect us. But bad for learning.

To learn "buffer overflows" you must deactivate the protection

some tips:

to deactivate gcc protection:
-fno-stack-protector
-fnomudflap
-D_FORTIFY_SOURCE=0
gcc overflow.c -o overflow -fno-stack-protector
gcc -fno-stack-protector -z execstack -o bug bug.c

to deactivate kernel protection:
echo "0" > /proc/sys/kernel/randomize_va_space
echo "0" > /proc/sys/kernel/exec-shield
echo "0" > /proc/sys/kernel/exec-shield-randomize


info about execstack


If you look at the programm with objdump (objdump -x cmd):
STACK off 0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**3
filesz 0x0000000000000000 memsz 0x0000000000000000 flags rw-
The stack is not executable!

you can do it executable with
gcc -fno-stack-protector -z execstack -o bug bug.c


If you want to learn heap or bss overflow you must do them executable too.
DYNAMIC off 0x0000000000000e40 vaddr 0x0000000000600e40 paddr 0x0000000000600e40 align 2**3
filesz 0x00000000000001a0 memsz 0x00000000000001a0 flags rw-

run Linux in Windows

there is a possibility to run Linux in a Windows environment. No partition, no extra linux on disk. You can install your linux in windows partition (ntfs, fat?) and start it running windows. No reboot anymore. Ok I virtually don't need it, because I use only linux (have any windows).


But here are the link: andLinux


andLinux based on coLinux.


coLinux, ulteo Desktop

simpler chat server and client in golang

server:

package main

import (
    "fmt";
    "net";
    "log";
    "os";
    "container/list";
    "strings";
    "bytes";
    "flag";
)

// flag for debuging info. or a simple log
var debug = flag.Bool("d", false, "set the debug modus( print informations )")

type ClientChat struct {
    Name string;        // name of user
    IN chan string;     // input channel for to send to user
    OUT chan string;    // input channel from user to all
    Con *net.Conn;      // connection of client
    Quit chan bool;     // quit channel for all goroutines
    ListChain *list.List;    // reference to list
}

// read from connection and return true if ok
func (c *ClientChat) Read(buf []byte) bool{
    nr, err := c.Con.Read(buf);
    if err!=nil {
        c.Close();
        return false;
    }
    Log("Read():  ", nr, " bytes");
    return true;
}

// close the connection and send quit to sender
func (c *ClientChat) Close() {
    c.Quit<-true;
    c.Con.Close();
    c.deleteFromList();
}

// compare two clients: name and network connection
func (c *ClientChat) Equal(cl *ClientChat) bool {
    if bytes.Equal(strings.Bytes(c.Name), strings.Bytes(cl.Name)) {
        if c.Con == cl.Con {
            return true;
        }
    }
    return false;
}

// delete the client from list
func (c *ClientChat) deleteFromList() {
    for e := c.ListChain.Front(); e != nil; e = e.Next() {
        client := e.Value.(ClientChat);
        if c.Equal(&client) {
            Log("deleteFromList(): ", c.Name);
            c.ListChain.Remove(e);
        }
    }
}

// func Log(v ...): loging. give log information if debug is true
func Log(v ...) {
    if *debug == true {
        ret := fmt.Sprint(v);
        log.Stdoutf("SERVER: %s", ret);
    }
}

// func test(): testing for error
func test(err os.Error, mesg string) {
    if err!=nil {
        log.Stderr("SERVER: ERROR: ", mesg);
         os.Exit(-1);
    } else
        Log("Ok: ", mesg);
}

// handlingINOUT(): handle inputs from client, and send it to all other client via channels.
func handlingINOUT(IN <-chan string, lst *list.List) {
    for {
        Log("handlingINOUT(): wait for input");
        input := <-IN;  // input, get from client
        // send to all client back
        Log("handlingINOUT(): handling input: ", input);
        for value := range lst.Iter() {
            client := value.(ClientChat);
            Log("handlingINOUT(): send to client: ", client.Name);
            client.IN<- input;
        }  
    }
}



// clientreceiver wait for an input from network, after geting data it send to
// handlingINOUT via a channel.
func clientreceiver(client *ClientChat) {
    buf := make([]byte, 2048);

    Log("clientreceiver(): start for: ", client.Name);
    for client.Read(buf) {
        
        if bytes.Equal(buf, strings.Bytes("/quit")) {
            client.Close();
            break;
        }
        Log("clientreceiver(): received from ",client.Name, " (", string(buf), ")");
        send := client.Name+"> "+string(buf);
        client.OUT<- send;
        for i:=0; i<2048;i++ {
            buf[i]=0x00;
        }
    }    

    client.OUT <- client.Name+" has left chat";
    Log("clientreceiver(): stop for: ", client.Name);
}

// clientsender(): get the data from handlingINOUT via channel (or quit signal from
// clientreceiver) and send it via network
func clientsender(client *ClientChat) {
    Log("clientsender(): start for: ", client.Name);
    for {
        Log("clientsender(): wait for input to send");
        select {
            case buf := <- client.IN:
                Log("clientsender(): send to \"", client.Name, "\": ", string(buf));
                client.Con.Write(strings.Bytes(buf));
            case <-client.Quit:
                Log("clientsender(): client want to quit");
                client.Con.Close();
                break;
        }
    }
    Log("clientsender(): stop for: ", client.Name);
}

// clientHandling(): get the username and create the clientsturct
// start the clientsender/receiver, add client to list.
func clientHandling(con *net.Conn, ch chan string, lst *list.List) {
    buf := make([]byte, 1024);
    con.Read(buf);
    name := string(buf);
    newclient := &ClientChat{name, make(chan string), ch, con, make(chan bool), lst};

    Log("clientHandling(): for ", name);
    go clientsender(newclient);
    go clientreceiver(newclient);
    lst.PushBack(*newclient);
    ch<- name+" has joinet the chat";
}

func main() {
    flag.Parse();
    Log("main(): start");

    // create the list of clients
    clientlist := list.New();
    in := make(chan string);
    Log("main(): start handlingINOUT()");
    go handlingINOUT(in, clientlist);
    
    // create the connection
    netlisten, err := net.Listen("tcp", "127.0.0.1:9988");
    test(err, "main Listen");
    defer netlisten.Close();

    for {
        // wait for clients
        Log("main(): wait for client ...");
        conn, err := netlisten.Accept();
        test(err, "main: Accept for client");
        go clientHandling(&conn, in, clientlist);
    }
}

Server has three part which are running as goroutines and communicate via channels.
1) handlingINOUT() simple wait for input of clientreceiver() and send to all clientsender() which are in the list.
2) clientreceiver() wait for his data from client via networkconnection and send it to a inputchannel to handlingINOUT
3) clientsender() wait for data from channel and send it to client

every client connection get a his own clientreceiver/sender and a list entry. on disconnection the list entry will be deleted.


client:

package main

import (
    "fmt";
    "net";
    "log";
    "os";
    "bytes";
    "bufio";
    "strings";
    "time";
    "flag";
)

var running bool;  // global variable if client is running

var debug = flag.Bool("d", false, "set the debug modus( print informations )")

// func Log(v ...): loging. give log information if debug is true
func Log(v ...) {
    if *debug == true {
        ret := fmt.Sprint(v);
        log.Stdoutf("CLIENT: %s", ret);
    }
}

// func test(): testing for error
func test(err os.Error, mesg string) {
    if err!=nil {
        log.Stderr("CLIENT: ERROR: ", mesg);
         os.Exit(-1);
    } else
        Log("Ok: ", mesg);
}

// read from connection and return true if ok
func Read(con *net.Conn) string{
    var buf [4048]byte;
    _, err := con.Read(&buf);
    if err!=nil {
        con.Close();
        running=false;
        return "Error in reading!";
    }
    str := string(&buf);
    fmt.Println();
    return string(str);
}

// clientsender(): read from stdin and send it via network
func clientsender(cn *net.Conn) {
    reader := bufio.NewReader(os.Stdin);
    for {
        fmt.Print("you> ");
        input, _ := reader.ReadBytes('\n');
        if bytes.Equal(input, strings.Bytes("/quit\n")) {
            cn.Write(strings.Bytes("/quit"));
            running = false;
            break;
        }
        Log("clientsender(): send: ", string(input[0:len(input)-1]));
        cn.Write(input[0:len(input)-1]);
    }
}

// clientreceiver(): wait for input from network and print it out
func clientreceiver(cn *net.Conn) {
    for running {
        fmt.Println(Read(cn));
        fmt.Print("you> ");
    }
}

func main() {
    flag.Parse();
    running = true;
    Log("main(): start ");
    
    // connect
    destination := "127.0.0.1:9988";
    Log("main(): connecto to ", destination);
    cn, err := net.Dial("tcp", "", destination);
    test(err, "dialing");
    defer cn.Close();
    Log("main(): connected ");

    // get the user name
    fmt.Print("Please give you name: ");
    reader := bufio.NewReader(os.Stdin);
    name, _ := reader.ReadBytes('\n');

    //cn.Write(strings.Bytes("User: "));
    cn.Write(name[0:len(name)-1]);

    // start receiver and sender
    Log("main(): start receiver");
    go clientreceiver(&cn);
    Log("main(): start sender");
    go clientsender(&cn);
    
    // wait for quiting (/quit). run until running is true
    for ;running; {
        time.Sleep(1*1e9);
    }
    Log("main(): stoped");
}

client start two goroutines: for getting input from stdin and send it to network. and get from network and print it out.

simple server/client

a simple server and client in golang.

server wait for a client and handle him, simple read and write, then close.

client connect to server, write then read to/from server.

server:

package main

import (
    . "fmt";
    "net";
    "os"; "log";
    "strings";
)

func test(err os.Error, mesg string) {
    if err!=nil {
        log.Stderr("SERVER: ERROR: ", mesg);
         os.Exit(-1);
    } else
        log.Stdout("SERVER: OK: ", mesg);
}


func main() {
    buf := make([] byte, 1500);

    Println("starting server...");

    netlisten, err := net.Listen("tcp", "127.0.0.1:9988");
    test(err, "Listen");
    defer netlisten.Close();
    
    for{
        Println("server wait for client ...");
        con, err := netlisten.Accept();
        test(err, "Accept for client");
        Println("client has connect to server");

        con.Read(buf);
           
        Println("readed: ", string(buf));

        con.Write(strings.Bytes("response from server"));
    }
}

client:

package main

import (
    . "fmt";
    "net";
    "os"; "log";
)

func test(err os.Error, mesg string) {
    if err!=nil {
        log.Stderr("CLIENT: ERROR: ", mesg);
         os.Exit(-1);
    } else
        log.Stdout("CLIENT: OK: ", mesg);
}

func main() {
    buf := make([] byte, 1500);

    Println("starting client");
    con, err := net.Dial("tcp", "", "127.0.0.1:9988");
    test(err, "dialing");
    defer con.Close();
    Println("client has connected to server");
    
    con.Write(strings.Bytes("das ist ein test"));

    con.Read(buf);
           
    Println("readed: ", string(buf));
}

Golang: crypto/aes

Here we test the golang aes encryption decryption. We simple encrypt and decrypt a text message with AES-128. That is a key with 16 byte length.

"NewCipher creates and returns a new Cipher. The key argument should be the AES key, either 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256."

package main

import (
    "crypto/aes";
    . "fmt";
    "os";
    "strings";
)

func main() {
    // a 32 byte long message
    msg := "This is long message text. len32";
    // some key, 16 Byte long
    key := []byte{0x2c, 0x88, 0x25, 0x1a, 0xaa, 0xae, 0xc2, 0xa2, 0xaf, 0xe7, 0x84, 0x8a, 0x10, 0xcf, 0xe3, 0x2a};

    Println("len of message: ", len(msg));
    Println("len of key: ", len(key));
    // create the new cipher
    c, err := aes.NewCipher(key);
    if err != nil {
   Println("Error: NewCipher(%d bytes) = %s", len(key), err);
   os.Exit(-1);
 }

    // now we convert our string into 32 long byte array
    msgbuf := strings.Bytes(msg);
    out := make([]byte, len(msg));
     
    c.Encrypt(msgbuf[0:16], out[0:16]);   // encrypt the first half
    c.Encrypt(msgbuf[16:32], out[16:32]); // encrypt the second half

    Println("len of encrypted: ", len(out));
    Println(">> ", out);

    // now we decrypt our encrypted text
    plain := make([]byte, len(out));
    c.Decrypt(out[0:16], plain[0:16]);   // decrypt the first half
    c.Decrypt(out[16:32], plain[16:32]); // decrypt the second half

    Println("msg: ", string(plain));
}

output:

len of message:  32
len of key:  16
len of encrypted:  32
>>  [0 173 125 174 152 165 226 181 32 25 196 177 81 243 134 79 55 152 215 72 239 85 123 219 82 30 231 89 185 194 67 203]
msg:  This is long message text. len32

Container in Go: ring

Ring:

A Ring is an element of a circular list, or ring. Rings do not have a beginning or end; a pointer to any ring element serves as reference to the entire ring. Empty rings are represented as nil Ring pointers. The zero value for a Ring is a one-element ring with a nil Value.

package main

import (
  . "fmt";
  "container/ring";
  "strings";
  "bytes";
)

// print the elements of the ring 
func PrintRing(r *ring.Ring) {
  Println("------------------------------");
  for value := range r.Iter() {
    Println("value: ", value);
  }
  Println("------------------------------");
}

func main() {
  // create a new ring with 10 items
  r := ring.New(10);

  Println("len of ring: ", r.Len());
  PrintRing(r);

  // set some value
  r.Value = "value 1";
  // take the next
  
  r = r.Next();
  r.Value = "value 2";

  r = r.Next();
  r.Value = "value 3";

  r = r.Next();
  r.Value = "value 4";

  PrintRing(r);


  // create a second ring with 3 item and set his value
  r2 := ring.New(3);
  r2.Value = "r2 value 1";
  r2 = r2.Next();
  r2.Value = "r2 value 2";
  r2 = r2.Next();
  r2.Value = "r2 value 3";
  PrintRing(r2);

  // merge ring2 into ring 1
  r = r.Link(r2);
  PrintRing(r);

  // remove a value in ring
  for p:=r.Next(); p!=r; p=p.Next() {
    if p.Value != nil {
      value := p.Value.(string);
      if bytes.Equal(strings.Bytes(value),strings.Bytes("r2 value 2")) {
        p.Value=nil;
      }
    }
  }

  PrintRing(r);
}

output:

len of ring:  10
------------------------------
value:  
value:  
value:  
value:  
value:  
value:  
value:  
value:  
value:  
value:  
------------------------------
------------------------------
value:  value 4
value:  
value:  
value:  
value:  
value:  
value:  
value:  value 1
value:  value 2
value:  value 3
------------------------------
------------------------------
value:  r2 value 3
value:  r2 value 1
value:  r2 value 2
------------------------------
------------------------------
value:  
value:  
value:  
value:  
value:  
value:  
value:  value 1
value:  value 2
value:  value 3
value:  value 4
value:  r2 value 3
value:  r2 value 1
value:  r2 value 2
------------------------------
------------------------------
value:  
value:  
value:  
value:  
value:  
value:  
value:  value 1
value:  value 2
value:  value 3
value:  value 4
value:  r2 value 3
value:  r2 value 1
value:  
------------------------------

Container in Go: list

List: (a doubly linked list)

The list is a double linked list of Elements. Element is an element in the linked list with Next() and Prev() pointer to other elements. Begining and ending of Elements are nil.

package main

import (
  . "fmt";
  "container/list";
  "strings";
  "bytes";
)

// print the elements of the list 
func PrintList(l *list.List) {
  Println("------------------------------");
  for value := range l.Iter() {
    Println("element: ", value);
  }
  Println("------------------------------");
}

func main() {
  // create a new list
  li := list.New();

  // add elements at end
  li.PushBack("list1");
  li.PushBack("list2");

  // add elements at begining
  li.PushFront("list3");
  
  PrintList(li);

  // get the first element from the list
  element := li.Front();
  str := element.Value;
  Println("value: ", str);

  // add a element before the first element
  li.InsertBefore("list4", element);

  // add after the element
  li.InsertAfter("list5", element);

  PrintList(li);

  // get the next element
  element = element.Next();
  Println("value: ", element.Value);

  // move the first element to back
  element = li.Front();
  li.MoveToBack(element);

  PrintList(li);

  // remove the first element
  element = li.Front();
  li.Remove(element);

  PrintList(li);
  
  // find the element with "list2" and remove it
  for element := li.Front(); element != nil; element = element.Next() {
  // don't use li.Iter(), because the interface chanel 
  // is geting the Value from the element back. not the element.
    value := element.Value.(string);

    if bytes.Equal(strings.Bytes(value),strings.Bytes("list2")) {
      li.Remove(element);
    }
  }

  PrintList(li);

}

the output is:

------------------------------
element:  list3
element:  list1
element:  list2
------------------------------
value:  list3
------------------------------
element:  list4
element:  list3
element:  list5
element:  list1
element:  list2
------------------------------
value:  list5
------------------------------
element:  list3
element:  list5
element:  list1
element:  list2
element:  list4
------------------------------
------------------------------
element:  list5
element:  list1
element:  list2
element:  list4
------------------------------
------------------------------
element:  list5
element:  list1
element:  list4
------------------------------

misunderstanding on casting in go

huch, have needed one day to understand that a function is in really was a cast.
look:
path.Walk(p.String(), pathIter(c), nil);

you can think pathIter(c) is a function. but:

type pathIter chan<- Path

pathIter is a typedefinition. Therefore is pathIter(c) not a function with parameter c, rahter a casting from c (is a Path channel) to pathIter.

input from stdion in go

package main

import (
    "os"; "fmt"; "bufio";
)

func main() {

    fmt.Print("input your name: ");

    br := bufio.NewReader(os.Stdin);

    name, _ := br.ReadString('\n');

    fmt.Println();
    fmt.Println("your name is: ", name);

}

func NewReader(rd io.Reader) *Reader NewReader returns a new Reader whose buffer has the default size.

func (b *Reader) ReadString(delim byte) (line string, err os.Error) read until delim byte.
here we read until enter.

urlescap in http

  url := "http://blub.org/b.html?v1=23&v2=bla&v=sdl+sdo";
  surl := http.URLEscape(url);

  fmt.Println(url);
  fmt.Println(surl);

  url2 := "http://это.порусс.ки/здесь.хтмл";
  surl2 := http.URLEscape(url2);

  fmt.Println(url2);
  fmt.Println(surl2);

output:

http://blub.org/b.html?v1=23&v2=bla&v=sdl+sdo
http://blub.org/b.html%3fv1%3d23%26v2%3dbla%26v%3dsdl%2bsdo

http://это.порусс.ки/здесь.хтмл
http://%d1%8d%d1%82%d0%be.%d0%bf%d0%be%d1%80%d1%83%d1%81%d1%81.%d0%ba%d0%b8/%d0%b7%d0%b4%d0%b5%d1%81%d1%8c.%d1%85%d1%82%d0%bc%d0%bb

http.URLUnescape(url string) do it back.

read a file and print the count of lines

package main

import (
  "io";
  "fmt";
  "os";
  "strings";
)

func main() {
  // read the file in bytes array
  b, err := io.ReadFile("readfile.go");
  if err!=nil {
    fmt.Println("error on read file");
    os.Exit(-1);
  } 
  
  // convert from bytes to string
  strbuffer := string(b);

  // split into lines
  lines := strings.Split(strbuffer, "\n", 0);

  // iterate each
  for i, line := range lines {
    fmt.Printf("%d:  %s\n", i, line);
  }
}