Cast boxed struct to boxed pointer - golang

I'm using Protobuf for Golang.
Protobuf generates message types where type pointer implements proto.Message().
e.g.

func (*SomeMessage) Message() {}

The protobuf lib have methods like Marshal(proto.Message)

Now to my actual issue.

message := SomeMessage {}
SendMessage(&message)

func SendMessage(message interface{}) {
   switch msg := message.(type) {
      case proto.Message:
          //send across the wire or whatever
      default:
          //non proto message, panic or whatever
   }
}

The above works fine.
However, If I don't pass the message as a pointer, then the code in SendMessage will not match, as the interface is only implemented on the SomeMessage pointer, not on the value.

What I would like to do is:

message := SomeMessage {}
SendMessage(message) //pass by value
//there are more stuff going on in my real code, but just trying to show the relevant parts

func SendMessage(message interface{}) {
   //match both pointer and value as proto.Message
   //and then turn the value into a pointer so that
   //other funcs or protobuf can consume it   

   message = MagicallyTurnBoxedValueIntoBoxedStruct(message)       

   switch msg := message.(type) {
      case proto.Message:
          //send across the wire or whatever
      default:
          //non proto message, panic or whatever
   }
}

preferably I'd like to be able to pass both as pointer and as value.
The reason why I want to pass by value, is that this can act as a poor mans isolation when passing messages across goroutines/threads etc.
(in lack of immutability)

All of this could probably be avoided if the protobuf generator generated allowed values to be treated as proto.Message() too.
Or if there was some nicer way to do immutable messages.

It's not super important,if its possible, cool, if its not, meh

[EDIT]

If I have the reflect.Type of the message and the reflect.Type of the pointer type of the message.
Is it somehow possible to create an instance of the pointer type pointing to the value using "reflect" ?

Normally, you can't take the address of a value which means you can't simply convert the interface{} to a pointer to satisfy Protobuf's requirement.

That said, you can dynamically create a new pointer then copy the value in to that then pass the newly allocated pointer to protobuf.

Here's an example on Play

The value -> pointer conversion is:

func mkPointer(i interface{}) interface{} {
	val := reflect.ValueOf(i)
	if val.Kind() == reflect.Ptr {
		return i
	}
	if val.CanAddr() {
		return val.Addr().Interface()
	}
	nv := reflect.New(reflect.TypeOf(i))
	nv.Elem().Set(val)
	return nv.Interface()
}

• We first see if it's a pointer, if so, just return the value.
• Then we check to see if it's addressable and return that.
• Lastly, we make a new instance of the type and copy the contents to that and return it.

Since this this copies the data, it may not be practical for your purposes. It will all depend on size of message and expected rate of calling with a value (as that will generate more garbage).