package grpc_hello_fuzz

import (
        "context"
        "log"
        "net"
        "time"

        "google.golang.org/grpc"
        pb "google.golang.org/grpc/examples/helloworld/helloworld"
)

var initialized = 0

type server struct {
        pb.UnimplementedGreeterServer
}

// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
        log.Printf("Received: %v", in.GetName())
        return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func FuzzHelloServer(data []byte) int {
        if initialized == 0 {
                lis, err := net.Listen("tcp", ":50051")
                if err != nil {
                        log.Printf("failed to listen: %v\n", err)
                        return 0
                }
                s := grpc.NewServer()
                pb.RegisterGreeterServer(s, &server{})
                // start server as a separate goroutine
                go func() {
                        if err := s.Serve(lis); err != nil {
                                log.Printf("failed to serve: %v\n", err)
                        }
                }()
                initialized = 1
        }

        conn, err := net.Dial("tcp", "localhost:50051")
        if err != nil {
                log.Printf("failed to dial: %v\n", err)
                return 0
        }
        conn.Write(data)
        response := make([]byte, 1+len(data))
        n, err := conn.Read(response)
        conn.Close()
        if err != nil || n == 0 {
                return 0
        }
        return 1
}

var fuzzdata []byte

func FuzzHelloClient(data []byte) int {
        if len(data) == 0 {
                return 0
        }
        if initialized == 0 {
                lis, err := net.Listen("tcp", ":50051")
                if err != nil {
                        log.Printf("failed to listen: %v\n", err)
                        return 0
                }
                go func() {
                        for {
                                conn, err := lis.Accept()
                                if err != nil {
                                        log.Printf("did not accept: %v", err)
                                        break
                                }
                                conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
                                request := make([]byte, 24)
                                n, err := conn.Read(request)
                                if err != nil || n == 0 {
                                        log.Printf("did not read: %v", err)
                                        conn.Close()
                                        break
                                }
                                n, err = conn.Write(fuzzdata)
                                if err != nil || n == 0 {
                                        log.Printf("did not write: %v", err)
                                }
                                conn.Close()
                        }
                }()
                initialized = 1
        }

        fuzzdata = data
        // Set up a connection to the server.
        ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*10)
        defer cancel()
        conn, err := grpc.DialContext(ctx, "localhost:50051", grpc.WithInsecure(), grpc.WithBlock())
        if err != nil {
                return 0
        }
        defer conn.Close()
        c := pb.NewGreeterClient(conn)

        // Contact the server and print out its response.
        r, err := c.SayHello(ctx, &pb.HelloRequest{Name: "world"})
        if err != nil {
                return 0
        }
        r.GetMessage()
        return 1
}

// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
//         protoc-gen-go v1.36.10
//         protoc        v5.27.1
// source: examples/helloworld/helloworld/helloworld.proto

package helloworld

import (
        protoreflect "google.golang.org/protobuf/reflect/protoreflect"
        protoimpl "google.golang.org/protobuf/runtime/protoimpl"
        reflect "reflect"
        sync "sync"
        unsafe "unsafe"
)

const (
        // Verify that this generated code is sufficiently up-to-date.
        _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
        // Verify that runtime/protoimpl is sufficiently up-to-date.
        _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// The request message containing the user's name.
type HelloRequest struct {
        state         protoimpl.MessageState `protogen:"open.v1"`
        Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
        unknownFields protoimpl.UnknownFields
        sizeCache     protoimpl.SizeCache
}

func (x *HelloRequest) Reset() {
        *x = HelloRequest{}
        mi := &file_examples_helloworld_helloworld_helloworld_proto_msgTypes[0]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
}

func (x *HelloRequest) String() string {
        return protoimpl.X.MessageStringOf(x)
}

func (*HelloRequest) ProtoMessage() {}

func (x *HelloRequest) ProtoReflect() protoreflect.Message {
        mi := &file_examples_helloworld_helloworld_helloworld_proto_msgTypes[0]
        if x != nil {
                ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
                if ms.LoadMessageInfo() == nil {
                        ms.StoreMessageInfo(mi)
                }
                return ms
        }
        return mi.MessageOf(x)
}

// Deprecated: Use HelloRequest.ProtoReflect.Descriptor instead.
func (*HelloRequest) Descriptor() ([]byte, []int) {
        return file_examples_helloworld_helloworld_helloworld_proto_rawDescGZIP(), []int{0}
}

func (x *HelloRequest) GetName() string {
        if x != nil {
                return x.Name
        }
        return ""
}

// The response message containing the greetings
type HelloReply struct {
        state         protoimpl.MessageState `protogen:"open.v1"`
        Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
        unknownFields protoimpl.UnknownFields
        sizeCache     protoimpl.SizeCache
}

func (x *HelloReply) Reset() {
        *x = HelloReply{}
        mi := &file_examples_helloworld_helloworld_helloworld_proto_msgTypes[1]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
}

func (x *HelloReply) String() string {
        return protoimpl.X.MessageStringOf(x)
}

func (*HelloReply) ProtoMessage() {}

func (x *HelloReply) ProtoReflect() protoreflect.Message {
        mi := &file_examples_helloworld_helloworld_helloworld_proto_msgTypes[1]
        if x != nil {
                ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
                if ms.LoadMessageInfo() == nil {
                        ms.StoreMessageInfo(mi)
                }
                return ms
        }
        return mi.MessageOf(x)
}

// Deprecated: Use HelloReply.ProtoReflect.Descriptor instead.
func (*HelloReply) Descriptor() ([]byte, []int) {
        return file_examples_helloworld_helloworld_helloworld_proto_rawDescGZIP(), []int{1}
}

func (x *HelloReply) GetMessage() string {
        if x != nil {
                return x.Message
        }
        return ""
}

var File_examples_helloworld_helloworld_helloworld_proto protoreflect.FileDescriptor

const file_examples_helloworld_helloworld_helloworld_proto_rawDesc = "" +
        "\n" +
        "/examples/helloworld/helloworld/helloworld.proto\x12\n" +
        "helloworld\"\"\n" +
        "\fHelloRequest\x12\x12\n" +
        "\x04name\x18\x01 \x01(\tR\x04name\"&\n" +
        "\n" +
        "HelloReply\x12\x18\n" +
        "\amessage\x18\x01 \x01(\tR\amessage2I\n" +
        "\aGreeter\x12>\n" +
        "\bSayHello\x12\x18.helloworld.HelloRequest\x1a\x16.helloworld.HelloReply\"\x00Bg\n" +
        "\x1bio.grpc.examples.helloworldB\x0fHelloWorldProtoP\x01Z5google.golang.org/grpc/examples/helloworld/helloworldb\x06proto3"

var (
        file_examples_helloworld_helloworld_helloworld_proto_rawDescOnce sync.Once
        file_examples_helloworld_helloworld_helloworld_proto_rawDescData []byte
)

func file_examples_helloworld_helloworld_helloworld_proto_rawDescGZIP() []byte {
        file_examples_helloworld_helloworld_helloworld_proto_rawDescOnce.Do(func() {
                file_examples_helloworld_helloworld_helloworld_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_examples_helloworld_helloworld_helloworld_proto_rawDesc), len(file_examples_helloworld_helloworld_helloworld_proto_rawDesc)))
        })
        return file_examples_helloworld_helloworld_helloworld_proto_rawDescData
}

var file_examples_helloworld_helloworld_helloworld_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_examples_helloworld_helloworld_helloworld_proto_goTypes = []any{
        (*HelloRequest)(nil), // 0: helloworld.HelloRequest
        (*HelloReply)(nil),   // 1: helloworld.HelloReply
}
var file_examples_helloworld_helloworld_helloworld_proto_depIdxs = []int32{
        0, // 0: helloworld.Greeter.SayHello:input_type -> helloworld.HelloRequest
        1, // 1: helloworld.Greeter.SayHello:output_type -> helloworld.HelloReply
        1, // [1:2] is the sub-list for method output_type
        0, // [0:1] is the sub-list for method input_type
        0, // [0:0] is the sub-list for extension type_name
        0, // [0:0] is the sub-list for extension extendee
        0, // [0:0] is the sub-list for field type_name
}

func init() { file_examples_helloworld_helloworld_helloworld_proto_init() }
func file_examples_helloworld_helloworld_helloworld_proto_init() {
        if File_examples_helloworld_helloworld_helloworld_proto != nil {
                return
        }
        type x struct{}
        out := protoimpl.TypeBuilder{
                File: protoimpl.DescBuilder{
                        GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
                        RawDescriptor: unsafe.Slice(unsafe.StringData(file_examples_helloworld_helloworld_helloworld_proto_rawDesc), len(file_examples_helloworld_helloworld_helloworld_proto_rawDesc)),
                        NumEnums:      0,
                        NumMessages:   2,
                        NumExtensions: 0,
                        NumServices:   1,
                },
                GoTypes:           file_examples_helloworld_helloworld_helloworld_proto_goTypes,
                DependencyIndexes: file_examples_helloworld_helloworld_helloworld_proto_depIdxs,
                MessageInfos:      file_examples_helloworld_helloworld_helloworld_proto_msgTypes,
        }.Build()
        File_examples_helloworld_helloworld_helloworld_proto = out.File
        file_examples_helloworld_helloworld_helloworld_proto_goTypes = nil
        file_examples_helloworld_helloworld_helloworld_proto_depIdxs = nil
}

// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v5.27.1
// source: examples/helloworld/helloworld/helloworld.proto

package helloworld

import (
        context "context"
        grpc "google.golang.org/grpc"
        codes "google.golang.org/grpc/codes"
        status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
        Greeter_SayHello_FullMethodName = "/helloworld.Greeter/SayHello"
)

// GreeterClient is the client API for Greeter service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
//
// The greeting service definition.
type GreeterClient interface {
        // Sends a greeting
        SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}

type greeterClient struct {
        cc grpc.ClientConnInterface
}

func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
        return &greeterClient{cc}
}

func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
        out := new(HelloReply)
        err := c.cc.Invoke(ctx, Greeter_SayHello_FullMethodName, in, out, cOpts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

// GreeterServer is the server API for Greeter service.
// All implementations must embed UnimplementedGreeterServer
// for forward compatibility.
//
// The greeting service definition.
type GreeterServer interface {
        // Sends a greeting
        SayHello(context.Context, *HelloRequest) (*HelloReply, error)
        mustEmbedUnimplementedGreeterServer()
}

// UnimplementedGreeterServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGreeterServer struct{}

func (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*HelloReply, error) {
        return nil, status.Error(codes.Unimplemented, "method SayHello not implemented")
}
func (UnimplementedGreeterServer) mustEmbedUnimplementedGreeterServer() {}
func (UnimplementedGreeterServer) testEmbeddedByValue()                 {}

// UnsafeGreeterServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GreeterServer will
// result in compilation errors.
type UnsafeGreeterServer interface {
        mustEmbedUnimplementedGreeterServer()
}

func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
        // If the following call panics, it indicates UnimplementedGreeterServer was
        // embedded by pointer and is nil.  This will cause panics if an
        // unimplemented method is ever invoked, so we test this at initialization
        // time to prevent it from happening at runtime later due to I/O.
        if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
                t.testEmbeddedByValue()
        }
        s.RegisterService(&Greeter_ServiceDesc, srv)
}

func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(HelloRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(GreeterServer).SayHello(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: Greeter_SayHello_FullMethodName,
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
        }
        return interceptor(ctx, in, info, handler)
}

// Greeter_ServiceDesc is the grpc.ServiceDesc for Greeter service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Greeter_ServiceDesc = grpc.ServiceDesc{
        ServiceName: "helloworld.Greeter",
        HandlerType: (*GreeterServer)(nil),
        Methods: []grpc.MethodDesc{
                {
                        MethodName: "SayHello",
                        Handler:    _Greeter_SayHello_Handler,
                },
        },
        Streams:  []grpc.StreamDesc{},
        Metadata: "examples/helloworld/helloworld/helloworld.proto",
}