← Back to branch summary

~kampka/ubuntu/quantal/zabbix/upstart-support

« back to all changes in this revision

Viewing changes to src/libs/zbxsms/sms.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Ablassmeier
  • Date: 2009-06-28 19:11:29 UTC
  • mfrom: (19.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090628191129-5esmmf2h3tbff1fv
http://bugs.debian.org/528426
http://bugs.debian.org/534096
http://bugs.debian.org/520197
http://bugs.debian.org/527559
http://bugs.debian.org/527600
http://bugs.debian.org/528571
http://bugs.debian.org/529157
http://bugs.debian.org/529502
http://bugs.debian.org/532344
* New upstream release
* Merge upstream config file to template (Closes: #528426)
* Move logrotate from Depends to Suggests (Closes: #534096)
* Server should not crash anymore if postgresql transaction fails
  (Closes: #520197)
* Update fr.po (Closes: #527559)
* Update es.po (Closes: #527600)
* Update sv.po (Closes: #528571)
* Update it.po (Closes: #529157)
* Update cs.po (Closes: #529502)
* Update de.po (Closes: #532344)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/zbxsms/sms.c
67
67
        return ret;
68
68
}
69
69
 
 
70
static int      check_modem_result(char *buffer, char **ebuf, char **sbuf, const char *expect, char *error, int max_error_len)
 
71
{
 
72
        const char      *__function_name = "check_modem_result";
 
73
        char            rcv[0xff];
 
74
        int             i, len, ret = SUCCEED;
 
75
 
 
76
        zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
 
77
 
 
78
        strcpy(rcv, *sbuf);
 
79
 
 
80
        do
 
81
        {
 
82
                len = *ebuf - *sbuf;
 
83
                for (i = 0; i < len && (*sbuf)[i] != '\n' && (*sbuf)[i] != '\r'; i++)
 
84
                        ; /* find first '\r' & '\n' */
 
85
 
 
86
                if (i < len)
 
87
                        (*sbuf)[i++] = '\0';
 
88
 
 
89
                ret = (NULL == strstr(*sbuf, expect)) ? FAIL : SUCCEED;
 
90
        
 
91
                *sbuf += i;
 
92
 
 
93
                if (*sbuf != buffer)
 
94
                {
 
95
                        memmove(buffer, *sbuf, *ebuf - *sbuf + 1); /* +1 for '\0' */
 
96
                        *ebuf -= *sbuf - buffer;
 
97
                        *sbuf = buffer;
 
98
                }
 
99
        } while (*sbuf < *ebuf && ret == FAIL);
 
100
 
 
101
        if (ret == FAIL && error)
 
102
        {
 
103
                zbx_snprintf(error, max_error_len, "Expected [%s] received [%s]",
 
104
                                expect,
 
105
                                rcv);
 
106
        }
 
107
 
 
108
        zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
 
109
 
 
110
        return ret;
 
111
}
 
112
 
70
113
int read_gsm(int fd, const char *expect, char *error, int max_error_len, int timeout_sec)
71
114
{
 
115
        const char      *__function_name = "read_gsm";
72
116
        static char     buffer[0xff];
73
117
        static char     *ebuf = buffer;
74
118
        static char     *sbuf = buffer;
75
 
        char            rcv[0xff];
76
 
 
77
119
        fd_set          fdset;
78
120
        struct timeval  tv;
79
 
 
80
 
        int     i, nbytes, len;
81
 
        int     ret = SUCCEED;
82
 
 
83
 
        if( timeout_sec == 0 )
 
121
        int             i, nbytes, ret = SUCCEED;
 
122
 
 
123
        zabbix_log(LOG_LEVEL_DEBUG, "In %s() [%s] [%s] [%s] [%s]", __function_name, expect, ebuf != buffer ? buffer : "NULL", ebuf != buffer ? ebuf : "NULL", ebuf != buffer ? sbuf : "NULL");
 
124
 
 
125
/*      if (timeout_sec == 0)
84
126
        {
85
127
                goto check_result;
86
 
        }
 
128
        }*/
 
129
        if ('\0' != *expect && ebuf != buffer &&
 
130
                        SUCCEED == check_modem_result(buffer, &ebuf, &sbuf, expect, error, max_error_len))
 
131
                goto out;
87
132
 
88
133
        tv.tv_sec  = timeout_sec;
89
134
        tv.tv_usec = 0;
97
142
                        if ( EINTR == errno )   continue;
98
143
                
99
144
                        zabbix_log(LOG_LEVEL_DEBUG, "Error select() for GSM modem. [%s]", strerror(errno));
100
 
                        if ( error ) zbx_snprintf(error,max_error_len, "Error select() for GSM modem. [%s]", strerror(errno));
101
 
 
102
 
                        return FAIL;
 
145
                        if (error)
 
146
                                zbx_snprintf(error,max_error_len, "Error select() for GSM modem. [%s]", strerror(errno));
 
147
                        ret = FAIL;
 
148
                        goto out;
103
149
                }
104
150
                else if ( i == 0 ) /*( 1 != i )*/
105
151
                {
117
163
 
118
164
        /* read characters into our string buffer */
119
165
        while ((nbytes = read(fd, ebuf, buffer + sizeof(buffer) - 1 - ebuf)) > 0)
120
 
        {
121
166
                ebuf += nbytes;
122
 
        }
123
167
        /* nul terminate the string and see if we got an OK response */
124
168
check_result:
125
169
        *ebuf = '\0';
126
170
 
127
171
        zabbix_log(LOG_LEVEL_DEBUG, "Read from GSM modem [%s]", sbuf);
128
 
        strcpy(rcv, sbuf);
129
172
 
130
 
        if( '\0' == *expect ) /* empty */
 
173
        if ('\0' == *expect) /* empty */
131
174
        {
132
175
                sbuf = ebuf = buffer;
133
176
                *ebuf = '\0';
134
 
                return ret;
135
 
        }
136
 
 
137
 
        do
138
 
        {
139
 
                len = ebuf - sbuf;
140
 
                for( i = 0; i < len && (sbuf[i] != '\n' && sbuf[i] != '\r'); i++ )
141
 
                        ; /* find first '\r' & '\n' */
142
 
 
143
 
                if(i < len)
144
 
                {
145
 
                        sbuf[i++] = '\0';
146
 
                }
147
 
 
148
 
                ret = ( strstr(sbuf, expect) == NULL ) ? FAIL : SUCCEED;
149
 
        
150
 
                sbuf += i;
151
 
 
152
 
                if ( sbuf != buffer )
153
 
                {
154
 
                        memmove(buffer, sbuf, ebuf - sbuf + 1); /* +1 for '\0' */
155
 
                        ebuf -= sbuf - buffer;
156
 
                        sbuf = buffer;
157
 
                }
158
 
        } while( (sbuf < ebuf) && (ret == FAIL) );
159
 
 
160
 
        if ( ret == FAIL && error )
161
 
        {
162
 
                zbx_snprintf(error, max_error_len, "Expected [%s] received [%s]",
163
 
                        expect,
164
 
                        rcv);
165
 
        }
 
177
                goto out;
 
178
        }
 
179
 
 
180
        ret = check_modem_result(buffer, &ebuf, &sbuf, expect, error, max_error_len);
 
181
out:
 
182
        zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
166
183
 
167
184
        return ret;
168
185
}
175
192
 
176
193
int     send_sms(char *device,char *number,char *message, char *error, int max_error_len)
177
194
{
 
195
        const char      *__function_name = "send_sms";
178
196
#define ZBX_AT_ESC      "\x1B"
179
197
#define ZBX_AT_CTRL_Z   "\x1A"
180
198
 
181
199
        zbx_sms_scenario scenario[] = {
182
200
/*  0  */       {ZBX_AT_ESC     , NULL          , 0     },      /* Send <ESC> */
183
 
/*  1  */       {"AT+CMEE=2\r"  , "OK"          , 5     },      /* verbose error values */
 
201
/*  1  */       {"AT+CMEE=2\r"  , ""/*"OK"*/    , 5     },      /* verbose error values */
184
202
/*  1  */       {"ATE0\r"       , "OK"          , 5     },      /* Turn off echo */
185
203
/*  2  */       {"AT\r"         , "OK"          , 5     },      /* Init modem */
186
204
/*  3  */       {"AT+CMGF=1\r"  , "OK"          , 5     },      /* Switch to text mode */
202
220
        int     f,
203
221
                ret = SUCCEED;
204
222
 
205
 
        zabbix_log( LOG_LEVEL_DEBUG, "In send_sms()");
 
223
        zabbix_log( LOG_LEVEL_DEBUG, "In %s()", __function_name);
206
224
        
207
225
        if ( -1 == (f = open(device, O_RDWR | O_NOCTTY | O_NDELAY)) )
208
226
        {
256
274
        tcsetattr(f, TCSANOW, &old_options);
257
275
        close(f);
258
276
 
259
 
        zabbix_log( LOG_LEVEL_DEBUG, "End of send_sms() [%s]",
260
 
                ret == SUCCEED ? "SUCCEED" : "FAIL" );
 
277
        zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
261
278
 
262
279
        return ret;
263
280
}