Module esme_skel

Copyright © 2004 Enrique Marcote Peña

• Description
• Function Index
• Function Details

Version: 1.1, { 6 Jul 2004} 11:26:49.

Behaviour: gen_esme.

Authors: Enrique Marcote Peña (mpquique_at_users.sourceforge.net) [web site: http://oserl.sourceforge.net/].

Description

You may use this skeleton as the starting point to implement your own ESMEs.

Function Index

Function Details

code_change/3

code_change(OldVsn, State, Extra) -> {ok, NewState}

• OldVsn = undefined | term()
• State = term()
• Extra = term
• NewState = term()

gen_esme - code_change/2 callback implementation.

Convert process state when code is changed.

handle_alert_notification/3

handle_alert_notification(X1::AlertNotification, From, State) -> Result

• AlertNotification = {alert_notification, Session, Pdu}
• Session = pid()
• Pdu = pdu()
• From = term()
• State = term()
• Result = {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, NewState}
• ParamList = [{ParamName, ParamValue}]
• ParamName = atom()
• ParamValue = term()
• NewState = term()
• Timeout = int()
• Reason = term()

gen_esme - handle_alert_notification/3 callback implementation.

Handle alert_notification requests from the peer SMSC.

handle_call/3

handle_call(Request, From, State) -> Result

• Request = term()
• From = {pid(), Tag}
• State = term()
• Result = {reply, Reply, NewState} | {reply, Reply, NewState, Timeout} | {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, Reply, NewState} | {stop, Reason, NewState}
• Reply = term()
• NewState = term()
• Timeout = int() | infinity
• Reason = term()

gen_esme - handle_call/3 callback implementation.

Handling call messages.

• On {stop, Reason, Reply, NewState} terminate/2 is called
• On {stop, Reason, NewState} terminate/2 is called

See also: terminate/2.

handle_cast/2

handle_cast(Request, State) -> Result

• Request = term()
• Result = {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, NewState}
• NewState = term()
• Timeout = int() | infinity
• Reason = normal | term()

gen_esme - handle_cast/2 callback implementation.

Handling cast messages.

• On {stop, Reason, State} terminate/2 is called.

See also: terminate/2.

handle_info/2

handle_info(Info, State) -> Result

• Info = timeout | term()
• State = term()
• Result = {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, NewState}
• NewState = term()
• Timeout = int() | infinity
• Reason = normal | term()

gen_esme - handle_info/2 callback implementation.

Handling all non call/cast messages.

• On {stop, Reason, State} terminate/2 is called.

See also: terminate/2.

handle_listen_error/1

handle_listen_error(State) -> Result

• State = term()
• Result = {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, NewState}
• NewState = term()
• Timeout = int()
• Reason = term()

gen_esme - handle_listen_error/1 callback implementation.

Handle listen failures.

handle_operation/3

handle_operation(X1::Operation, From, S::State) -> Result

• Operation = {deliver_sm, Session, Pdu} | {data_sm, Session, Pdu}
• Session = pid()
• Pdu = pdu()
• From = term()
• State = term()
• Result = {reply, Reply, NewState} | {reply, Reply, NewState, Timeout} | {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, Reply, NewState} | {stop, Reason, NewState}
• Reply = {ok, ParamList} | {error, Error, ParamList}
• ParamList = [{ParamName, ParamValue}]
• ParamName = atom()
• ParamValue = term()
• NewState = term()
• Timeout = int()
• Reason = term()

gen_esme - handle_operation/3 callback implementation.

Handle deliver_sm and data_sm operations (from the peer SMSCs) to the callback ESME.

The ParamList included in the response is used to construct the response PDU. If a command_status other than ESME_ROK is to be returned by the ESME in the response PDU, the callback should return the term {error, Error, ParamList}, where Error is the desired command_status error code.

handle_outbind/3

handle_outbind(X1::Outbind, From, State) -> Result

• OutBind = {outbind, Session, Pdu}
• Session = pid()
• Pdu = pdu()
• From = term()
• State = term()
• Result = {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, NewState}
• ParamList = [{ParamName, ParamValue}]
• ParamName = atom()
• ParamValue = term()
• NewState = term()
• Timeout = int()
• Reason = term()

gen_esme - handle_outbind/3 callback implementation.

Handle oubind requests from the peer SMSC.

handle_unbind/3

handle_unbind(X1::Unbind, From, State) -> Result

• Unbind = {unbind, Session, Pdu}
• Session = pid()
• Pdu = pdu()
• Result = {reply, Reply, NewState} | {reply, Reply, NewState, Timeout} | {noreply, NewState} | {noreply, NewState, Timeout} | {stop, Reason, Reply, NewState} | {stop, Reason, NewState}
• Reply = ok | {error, Error}
• Error = int()
• NewState = term()
• Timeout = int()
• Reason = term()

gen_esme - handle_unbind/3 callback implementation.

Handle unbind requests from the peer SMSC.

If ok returned an unbind_resp with a ESME_ROK command_status is sent to the MC and the session moves into the unbound state. When {error, Error} is returned by the ESME, the response PDU sent by the session to the MC will have an Error command_status and the session will remain on it's current bound state (bound_rx, bound_tx or bound_trx).

init/1

init(X1::Args) -> Result

• Args = term()
• Result = {ok, State} | {ok, State, Timeout} | ignore | {stop, Reason}
• State = term()
• Timeout = int() | infinity
• Reason = term()

gen_esme - init/1 callback implementation.

Initiates the server.

start_link/0

start_link() -> Result

• Result = {ok, Pid} | ignore | {error, Error}
• Pid = pid()
• Error = {already_started, Pid} | term()

Starts the ESME server.

See also: gen_esme, start/0.

stop/0

stop() -> ok

Equivalent to gen_esme:call(SERVER, die, 10000).

Stops the ESME server.

See also: handle_call/3.

terminate/2

terminate(Reason, State) -> ok

• Reason = normal | shutdown | term()
• State = term()

gen_esme - terminate/2 callback implementation.

Shutdown the ESME server.

Return value is ignored by gen_esme.