public class BroConnection : IDisposable

Public Class BroConnection
	Implements IDisposable

type BroConnection =  
    class
        interface IDisposable
    end

public class BroConnection implements IDisposable

BroccoliSharp.BroConnection = function();

Type.createClass(
	'BroccoliSharp.BroConnection',
	null,
	IDisposable);

BroConnection connection = new BroConnection("bro.yourorg.com:1234"))

// Register for events before connecting to Bro...
connection.RegisterForEvent("foo");

// Connect to remote Bro
connection.Connect();

Console.WriteLine("Peer class = " + connection.PeerClass);

event report_conns(req_id: int, dest_host: string, dest_port: port, min_size: count);

BroEvent ev = new BroEvent("report_conns");

ev.AddParameter(new BroValue(0, BroType.Int));      // req_id
ev.AddParameter("desthost.destdomain.com");         // dest_host
ev.AddParameter(new BroPort(80, "tcp");             // dest_port
ev.AddParameter(new BroValue(1000, BroType.Count)); // min_size

ev.AddParameter(new BroValue(2, BroType.Enum, "transport_proto"));

ev.AddParameter(2, BroType.Enum, "transport_proto");

connection.SendEvent(ev);

connection.EventQueue.Length;

// Establish event handler for Bro events
connection.ReceivedEvent += connection_ReceivedEvent;

// Bro event handler - called when a new Bro event is received
static void connection_ReceivedEvent(object sender, BroEventArgs e)
{
    if (e.EventName == "foo")
    {
        // Code to handle foo event...
    }
}

event report_conn(req_id: int, conn: connection);

connection.RegisterForEvent("report_conn");

// Bro event handler
static void connection_ReceivedEvent(object sender, BroEventArgs e)
{
    // Raised when a new Bro event is received
    switch (e.EventName)
    {
        case "foo":
            // Handle foo event
            Console.WriteLine("Received event \"foo\" with {0} parameters at {1}", e.Parameters.Length, e.EventTime);

            for (int i = 0; i < e.Parameters.Length; i++)
                Console.WriteLine("    Event \"foo\" parameter[{0}] = {1}", i, e.Parameters[i]);

            break;
        default:
            Console.WriteLine("Received unexpected event \"{0}\".", e.EventName);
            break;
    }
}

using System;
using System.Net.Sockets;
using BroccoliSharp;

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            using (BroConnection connection = new BroConnection("bro.yourorg.com:1234"))
            {
                // Establish event handler for received Bro events
                connection.ReceivedEvent += connection_ReceivedEvent;

                // Register for event "foo"
                connection.RegisterForEvent("foo");

                // Connect to remote Bro
                connection.Connect();

                Console.WriteLine("Peer class = " + connection.PeerClass);

                // Create a new event
                BroEvent bar = new BroEvent("bar");

                bar.AddParameter("Text parameter");
                bar.AddParameter(true);
                bar.AddParameter("192.168.1.1", BroType.IpAddr);
                bar.AddParameter(new BroPort(80, ProtocolType.Tcp));
                bar.AddParameter(2, BroType.Enum, "transport_proto");
                bar.AddParameter(BroTime.Now);

                // Send the event
                bool result = connection.SendEvent(bar);
                Console.WriteLine("Event \"bar\" {0}", result ? "was sent or queued for later delivery" : "failed to send or queue");

                // Process any incoming events...
                connection.ProcessInput();

                Console.ReadLine();

                // Unregister from event "foo"
                connection.UnregisterForEvent("foo");
            }
        }

        // Bro event handler
        static void connection_ReceivedEvent(object sender, BroEventArgs e)
        {
            // Raised when a new Bro event is received
            switch (e.EventName)
            {
                case "foo":
                    // Handle foo event
                    Console.WriteLine("Received event \"foo\" with {0} parameters at {1}", e.Parameters.Length, e.EventTime);

                    for (int i = 0; i < e.Parameters.Length; i++)
                        Console.WriteLine("    Event \"foo\" parameter[{0}] = {1}", i, e.Parameters[i]);

                    break;
                default:
                    Console.WriteLine("Received unexpected event \"{0}\".", e.EventName);
                    break;
            }
        }
    }
}

Option Strict On
Imports BroccoliSharp
Imports System.Net.Sockets

Module Program

    Sub Main()

        Using connection As New BroConnection("bro.yourorg.com:1234")
            ' Establish event handler for received Bro events
            AddHandler connection.ReceivedEvent, AddressOf connection_ReceivedEvent

            ' Register for event "foo"
            connection.RegisterForEvent("foo")

            ' Connect to remote Bro
            connection.Connect()

            Console.WriteLine("Peer class = " + connection.PeerClass)

            ' Create a new event
            Dim bar As New BroEvent("bar")

            bar.AddParameter("Text parameter")
            bar.AddParameter(True)
            bar.AddParameter("192.168.1.1", BroType.IpAddr)
            bar.AddParameter(New BroPort(80, ProtocolType.Tcp))
            bar.AddParameter(2, BroType.Enum, "transport_proto")
            bar.AddParameter(BroTime.Now)

            ' Send the event
            Dim result As Boolean = connection.SendEvent(bar)
            Console.WriteLine("Event ""bar"" {0}", IIf(result, "was sent or queued for later delivery", "failed to send or queue"))

            ' Process any incoming events...
            connection.ProcessInput()

            Console.ReadLine()

            ' Unregister from event "foo"
            connection.UnregisterForEvent("foo")
        End Using

    End Sub

    ' Bro event handler
    Sub connection_ReceivedEvent(sender As Object, e As BroEventArgs)

        ' Raised when a new Bro event is received
        Select Case e.EventName
            Case "foo"
                ' Handle foo event
                Console.WriteLine("Received event ""foo"" with {0} parameters at {1}", e.Parameters.Length, e.EventTime)

                For i As Integer = 0 To e.Parameters.Length - 1
                    Console.WriteLine("    Event ""foo"" parameter[{0}] = {1}", i, e.Parameters(i))
                Next
            Case Else
                Console.WriteLine("Received unexpected event ""{0}"".", e.EventName)
        End Select

    End Sub

End Module

No code example is currently available or this language may not be supported.

package Example;

// Imports based on IKVM.NET stubs: http://sourceforge.net/p/ikvm/wiki/Ikvmstub/
import cli.BroccoliSharp.*;
import cli.System.Net.Sockets.*;

public class Program
{
    public static void main(String[] args)
    {
        BroConnection connection = new BroConnection("bro.yourorg.com:1234");

        // Establish event handler for received Bro events
        connection.add_ReceivedEvent(new EventHandler<BroEventArgs>(connection_ReceivedEvent));

        // Register for event "foo"
        connection.RegisterForEvent("foo");

        // Connect to remote Bro
        connection.Connect();

        System.out.println("Peer class = " + connection.get_PeerClass());

        // Create a new event
        BroEvent bar = new BroEvent("bar");

        bar.AddParameter("Text parameter");
        bar.AddParameter(true);
        bar.AddParameter("192.168.1.1", BroType.IpAddr);
        bar.AddParameter(new BroPort(80, ProtocolType.Tcp));
        bar.AddParameter(2, BroType.Enum, "transport_proto");
        bar.AddParameter(BroTime.get_Now());

        // Send the event
        bool result = connection.SendEvent(bar);
        System.out.format("Event \"bar\" %s%n", result ? "was sent or queued for later delivery" : "failed to send or queue");

        // Process any incoming events...
        connection.ProcessInput();

        System.in.read();

        // Unregister from event "foo"
        connection.UnregisterForEvent("foo");
        connection.Dispose();
    }

    // Bro event handler
    static void connection_ReceivedEvent(object sender, BroEventArgs e)
    {
        // Raised when a new Bro event is received
        String eventName = e.get_EventName();
        IBroValue[] parameters = e.get_Parameters();

        switch (eventName)
        {
            case "foo":
                // Handle foo event
                System.out.format("Received event \"foo\" with %d parameters at %s%n", parameters.length, e.get_EventTime().ToString());

                for (int i = 0; i < parameters.length; i++)
                    System.out.format("    Event \"foo\" parameter[%d] = %s%n", i, parameters[i].toString());

                break;
            default:
                System.out.format("Received unexpected event \"%s\".%n", eventName);
                break;
        }
    }
}

No code example is currently available or this language may not be supported.

using System;
using System.Threading;
using BroccoliSharp;

namespace BroPing
{
    class Program
    {
        static int Main(string[] args)
        {
            if (args.Length != 1)
            {
                Console.WriteLine("Usage:");
                Console.WriteLine("    BroPing host:port");
                return 1;
            }

            try
            {
                string hostName = args[0];

                Console.WriteLine("Attempting to establish Bro connection to \"{0}\"...", hostName);

                // Create the connection object
                using (BroConnection connection = new BroConnection(hostName))
                {
                    // Register to receive the pong event
                    connection.RegisterForEvent("pong", e =>
                    {
                        BroValue[] values = e.Parameters;
                        DateTime src_time = values[0];
                        DateTime dst_time = values[1];

                        Console.WriteLine("pong event from {0}: seq={1}, time={2}/{3} s",
                            hostName,
                            values[2],
                            (dst_time - src_time).TotalSeconds,
                            (BroTime.Now - src_time).TotalSeconds);
                    });

                    connection.Connect();

                    Console.WriteLine("Bro connection established. Starting ping cycle, press any key to cancel...");

                    int seq = 0;

                    while (!Console.KeyAvailable)
                    {
                        // Send ping
                        connection.SendEvent("ping", BroTime.Now, new BroValue(seq++, BroType.Count));

                        // Process any received responses
                        connection.ProcessInput();

                        // Wait one second between pings
                        Thread.Sleep(1000);
                    }
                }

                return 0;
            }
            catch (Exception ex)
            {
                Console.Write("Exception: {0}{1}", ex.Message, Environment.NewLine);
                return 1;
            }
        }
    }
}