Email Gateway

[tremmert81]

First, great progress on the project..

Next, it would be great to have an email Gateway built in. The BBS operator could input SMTP settings, and the users on Meshtastic could use your BBS software to send an email. In an emergency, it is great to be able to communicate internally within the mesh. But sometimes, it would be nice to be able to send a message to someone outside of the local network to let them know your status or send a request for help. By utilizing email or SMS, we could communicate with those without access to Meshtastic or outside of range.

For testing, I created a sample script that does the following:

1. Help menu showing the format of the command: email
2. Sets rate limits so a user can only send 1 email per 3 minutes
3. Sends a Success/failure message back to the user to let them know the message status

There are several free SMTP services that allow 1,000 emails per month to be sent. This could be a good basic system. If we were able to introduce SMS, we could integrate with the Twilio API or similar. Local groups (like the Austin Mesh) could raise money to support the SMS gateway.

[SpudGunMan]

Thanks!

Interesting idea! Sounds fun!

To keep it "free" could have a command to set a email to the node so ..

User sends: setsms [email protected]
User sends: sms I am ok
Bot, sends email to stored address

Optionally user sets a email
User sends: setemail [email protected]
User sends: email warranty expired
Bot, sends email to stored address

User sends: email [email protected] # hello world
Bot, sends email to address

[tremmert81]

Below is my code... I am not familiar with Github, so I am not sure how to properly share this code. It will only respond to direct messages. But it is tested and works to send an email...

import time
import sys
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import re
from pubsub import pub
from meshtastic.tcp_interface import TCPInterface
from meshtastic import portnums_pb2
from collections import defaultdict

# Meshtastic settings
node_ip = '127.0.0.1'

# Email settings
SMTP_SERVER = "smtp.gmail.com"  # Replace with your SMTP server
SMTP_PORT = 587  # Replace with your SMTP port
SMTP_USERNAME = "[email protected]"  # Replace with your email
SMTP_PASSWORD = "your_app_password"  # Replace with your password/app password
FROM_EMAIL = "[email protected]"  # Replace with your sender email
EMAIL_SUBJECT = "Email from the Meshtastic Network"

# Rate limiting settings
RATE_LIMIT_SECONDS = 60
last_email_time = defaultdict(float)  # Track last email time for each user

def check_rate_limit(user_id):
    """Check if user has exceeded rate limit"""
    current_time = time.time()
    time_since_last = current_time - last_email_time[user_id]
    
    if time_since_last < RATE_LIMIT_SECONDS:
        return False, int(RATE_LIMIT_SECONDS - time_since_last)
    
    last_email_time[user_id] = current_time
    return True, 0

def send_email(to_email, body):
    """Send an email using the configured SMTP server"""
    try:
        # Create message
        msg = MIMEMultipart()
        msg['From'] = FROM_EMAIL
        msg['To'] = to_email
        msg['Subject'] = EMAIL_SUBJECT
        
        msg.attach(MIMEText(body, 'plain'))
        
        # Create SMTP connection
        server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
        server.starttls()
        server.login(SMTP_USERNAME, SMTP_PASSWORD)
        
        # Send email
        server.send_message(msg)
        server.quit()
        return True, "Email sent successfully"
        
    except Exception as e:
        return False, f"Failed to send email: {str(e)}"

def process_email_command(command):
    """Process the email command and extract recipient and message"""
    # Expected format: email [email protected] Your message here
    parts = command.split(' ', 2)
    
    if len(parts) < 3:
        return False, "Invalid format. Use: email <email address> <message>"
        
    email_addr = parts[1]
    message = parts[2]
    
    # Basic email validation
    email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    if not re.match(email_pattern, email_addr):
        return False, "Invalid email address format"
        
    return True, (email_addr, message)

def process_command(command, interface, fromnum):
    """Process commands and return appropriate responses"""
    command = command.strip()
    command_lower = command.lower()
    
    if command_lower == "help":
        # Send help menu in multiple messages
        help_messages = [
            "Available commands:",
            "1. EMAIL - Send an email through the network\n   Format: email <email_address> <message>\n   Example: email [email protected] Hello",
            "   Note: Limited to one email per minute per user",
            "2. SMS - Send an SMS (coming soon)\n   Format: SMS <phone number>"
        ]
        
        # Send each part of the help menu separately
        for msg in help_messages:
            try:
                interface.sendText(msg, destinationId=fromnum)
                time.sleep(1)  # Add delay between messages
            except Exception as e:
                print(f"Error sending help message: {e}")
                raise
                
    elif command_lower.startswith("email "):
        # Check rate limit first
        can_send, wait_time = check_rate_limit(fromnum)
        if not can_send:
            response = f"Please wait {wait_time} seconds before sending another email"
        else:
            # Process email command
            success, result = process_email_command(command)
            
            if success:
                email_addr, message = result
                # Send the email
                success, email_result = send_email(email_addr, message)
                response = email_result
            else:
                response = result
        
        # Send response
        interface.sendText(response, destinationId=fromnum)
    
    else:
        response = "Unrecognized command. Type help for a list of commands"
        interface.sendText(response, destinationId=fromnum)

def get_node_info(node_ip):
    """Get node information with retry logic"""
    max_retries = 3
    retry_delay = 5  # seconds
    
    for attempt in range(max_retries):
        try:
            print(f"Initializing TcpInterface to get node info (attempt {attempt + 1})...")
            local = TCPInterface(hostname=node_ip)
            node_info = local.nodes
            local.close()
            print("Node info retrieved.")
            return node_info
        except Exception as e:
            print(f"Error getting node info: {e}")
            if attempt < max_retries - 1:
                print(f"Retrying in {retry_delay} seconds...")
                time.sleep(retry_delay)
            else:
                raise

def parse_node_info(node_info):
    print("Parsing node info...")
    nodes = []
    for node_id, node in node_info.items():
        nodes.append({
            'num': node_id,
            'user': {
                'shortName': node.get('user', {}).get('shortName', 'Unknown')
            }
        })
    print("Node info parsed.")
    return nodes

def on_receive(packet, interface, node_list):
    """Handle received messages with improved error handling"""
    try:
        # First check if this is a valid message packet
        if not isinstance(packet, dict):
            print(f"Received invalid packet type: {type(packet)}")
            return
            
        # Check if this is a text message
        if packet.get('decoded', {}).get('portnum') == 'TEXT_MESSAGE_APP':
            try:
                message = packet['decoded']['payload'].decode('utf-8')
                fromnum = packet.get('fromId')
                want_ack = packet.get('wantAck', False)
                
                # Skip processing if we don't have a valid fromId
                if not fromnum:
                    print("Received message without valid fromId")
                    return
                    
                shortname = next((node['user']['shortName'] 
                                for node in node_list 
                                if node['num'] == fromnum), 'Unknown')
                
                message_type = 'Direct Message' if want_ack else 'Channel Message'
                print(f"{shortname}: {message} ({message_type})")
                
                # Only process commands from direct messages
                if want_ack:
                    process_command(message, interface, fromnum)
                    
            except (KeyError, AttributeError) as e:
                print(f"Error processing message content: {e}")
                
        elif 'mqttClientProxyMessage' in str(packet):
            # This is an MQTT message, not a direct message
            print("Received MQTT message - ignoring")
            return
            
        else:
            # Log unknown packet type for debugging
            print(f"Received unknown packet type: {packet.keys()}")
            
    except Exception as e:
        print(f"Error in message handling: {str(e)}")
        print(f"Packet content: {packet}")  # Log the packet content for debugging

def setup_interface(node_ip):
    """Set up the TCP interface with the node"""
    interface = TCPInterface(hostname=node_ip)
    print("TcpInterface setup for listening and sending.")
    return interface

def main():
    print(f"Using node IP: {node_ip}")
    
    while True:  # Main program loop
        try:
            # Retrieve and parse node information
            node_info = get_node_info(node_ip)
            node_list = parse_node_info(node_info)
            
            # Print node list for debugging
            print("Node List:")
            for node in node_list:
                print(node)
            
            # Set up the TcpInterface for message listening and sending
            local = setup_interface(node_ip)
            
            # Subscribe the callback function to message reception
            def on_receive_wrapper(packet, interface):
                on_receive(packet, interface, node_list)
            
            pub.subscribe(on_receive_wrapper, "meshtastic.receive")
            print("Subscribed to meshtastic.receive")
            
            # Keep the script running to listen for messages
            while True:
                sys.stdout.flush()
                time.sleep(1)  # Sleep to reduce CPU usage
                
        except KeyboardInterrupt:
            print("Script terminated by user")
            try:
                local.close()
            except:
                pass
            sys.exit(0)
            
        except Exception as e:
            print(f"Connection error: {e}")
            print("Attempting to reconnect in 5 seconds...")
            try:
                local.close()
            except:
                pass
            time.sleep(5)
            print("Reconnecting...")
            pub.unsubscribe(on_receive_wrapper, "meshtastic.receive")
            continue

if __name__ == "__main__":
    main()

[SpudGunMan]

progress here 766ff0a

[tremmert81]

Wonderful...

Side note, I have been using mailersend.com for a free SMTP server that has been working well. This is the server that I intend to use, or perhaps create a new Gmail account...

[SpudGunMan]

Got some more progress done, might be possible to allow two way; haven't tested yet but any input let me know :)

[SpudGunMan]

Enough code in to start testing the feature @tremmert81

[SpudGunMan]

basic functionality tested and now in main code line - will continue to enhance