# server.go
```go
package main

/*
#cgo pkg-config: libzmq
#include <zmq.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <malloc.h>
*/
import "C"
// sudo apt-get install libzmq3-dev
import (
	"unsafe"
	"fmt"
)

func main() {
	context := C.zmq_ctx_new()
	defer C.zmq_ctx_destroy(context)

	responder := C.zmq_socket(context, C.ZMQ_REP)
	defer C.zmq_close(responder)

	rc := C.zmq_bind(responder, C.CString("tcp://*:5555"))
	if rc != 0 {
		panic("Failed to bind socket")
	}

	for {
		buffer := make([]byte, 10)
		C.zmq_recv(responder, unsafe.Pointer(&buffer[0]), 10, 0)
		fmt.Println("Received Hello")
		C.sleep(1)
		message := unsafe.Pointer(C.CString("World"))
		defer C.free(message)
		C.zmq_send(responder, message, 5, 0)
	}
}
```

# client.go
```go
package main
/*
#cgo pkg-config: libzmq
#include <zmq.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
*/
import "C"
import (
	"fmt"
	"unsafe"
)

func main(){
	fmt.Println("Connecting to hello world server…")
	
	context := C.zmq_ctx_new()
	defer C.zmq_ctx_destroy(context)

	requester := C.zmq_socket(context, C.ZMQ_REQ)
	defer C.zmq_close(requester)

	C.zmq_connect(requester, C.CString("tcp://localhost:5555"))

	// for request_nbr := range 10 {
	
	for request_nbr := 0; request_nbr < 10; request_nbr++ {
		buffer := make([]byte, 10)
		fmt.Printf("Sending Hello %d...\n", request_nbr)
		msg := unsafe.Pointer(C.CString("Hello"))
		defer C.free(msg)
		C.zmq_send(requester, msg, 5, 0);
		C.zmq_recv(requester, unsafe.Pointer(&buffer[0]), 10, 0);
		fmt.Printf("Received World %d\n", request_nbr)
	}
}
```

# multipart

```go
package main

/*
#cgo pkg-config: libzmq
#include <zmq.h>
#include <string.h>
#include <stdlib.h>
*/
import "C"
import (
    "fmt"
    "unsafe"
    "time"
)

func sender(context unsafe.Pointer) {
    socket, _ := C.zmq_socket(context, C.ZMQ_PUSH)
    defer C.zmq_close(socket)

    C.zmq_connect(socket, C.CString("tcp://localhost:5555"))

    // Sending a multi-part message
    var message C.zmq_msg_t

    // First part
    C.zmq_msg_init_size(&message, C.size_t(5))
    C.memcpy(C.zmq_msg_data(&message), unsafe.Pointer(C.CString("Hello")), C.size_t(5))
    C.zmq_msg_send(&message, socket, C.ZMQ_SNDMORE)
    C.zmq_msg_close(&message)

    // Second part
    C.zmq_msg_init_size(&message, C.size_t(6))
    C.memcpy(C.zmq_msg_data(&message), unsafe.Pointer(C.CString("World!")), C.size_t(6))
    C.zmq_msg_send(&message, socket, C.ZMQ_SNDMORE)
    C.zmq_msg_close(&message)

    // Last part
    C.zmq_msg_init_size(&message, C.size_t(3))
    C.memcpy(C.zmq_msg_data(&message), unsafe.Pointer(C.CString("End")), C.size_t(3))
    C.zmq_msg_send(&message, socket, 0)
    C.zmq_msg_close(&message)
}

func receiver(context unsafe.Pointer) {
    socket, _ := C.zmq_socket(context, C.ZMQ_PULL)
    defer C.zmq_close(socket)

    C.zmq_bind(socket, C.CString("tcp://*:5555"))

    for {
        var message C.zmq_msg_t
        C.zmq_msg_init(&message)

        more := C.int(1)
        moreSize := C.size_t(unsafe.Sizeof(more))
        part := 0

        for more != 0 {
            C.zmq_msg_recv(&message, socket, 0)

            size := C.zmq_msg_size(&message)
            data := C.GoBytes(C.zmq_msg_data(&message), C.int(size))

            part++
            fmt.Printf("Received part %d: %s\n", part, string(data))

            C.zmq_getsockopt(socket, C.ZMQ_RCVMORE, unsafe.Pointer(&more), &moreSize)
            C.zmq_msg_close(&message)

            if more != 0 {
                C.zmq_msg_init(&message)
            }
        }
        fmt.Println("End of multipart message\n")
    }
}

func main() {
    context, _ := C.zmq_ctx_new()
    defer C.zmq_ctx_destroy(context)

    go sender(context)
    time.Sleep(time.Second) // Give some time for the sender to connect
    receiver(context)
}
```