nmxptool.c 8.82 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <nmxp.h>

#include "nmxptool_getoptlong.h"

#include "config.h"

11
12
#ifdef HAVE___SRC_SEEDLINK_PLUGIN_H
#include "seedlink_plugin.h"
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#endif


int main (int argc, char **argv) {
    int naqssock;
    NMXP_CHAN_LIST *channelList;
    NMXP_CHAN_LIST *channelList_subset;
    uint32_t connection_time;
    int request_SOCKET_OK;
    int i_chan;

    NMXP_MSG_SERVER type;
    void *buffer;
    uint32_t length;
    int ret;

    FILE *outfile = NULL;
    char filename[500];
    char *station_code = NULL, *channel_code = NULL;

    NMXP_DATA_PROCESS *pd;

35
    NMXPTOOL_PARAMS params;
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#ifdef HAVE_LIBMSEED
    /* Mini-SEED variables */
    NMXP_DATA_SEED data_seed;

    /* Init mini-SEED variables */
    nmxp_data_seed_init(&data_seed);
#endif


    nmxp_log(-1, 0);

    /* Initialize params from argument values */
    if(nmxptool_getopt_long(argc, argv, &params) != 0) {
	return 1;
    }

    /* Check consistency of params */
    if(nmxptool_check_params(&params) != 0) {
	return 1;
    }

    /* List available channels on server */
    if(params.flag_listchannels) {

	channelList = nmxp_getAvailableChannelList(params.hostname, params.portnumberpds, NMXP_DATA_TIMESERIES);
	nmxp_chan_print_channelList(channelList);

	return 1;
    }

    /* Get list of available channels and get a subset list of params.channels */
    channelList = nmxp_getAvailableChannelList(params.hostname, params.portnumberpds, NMXP_DATA_TIMESERIES);
    channelList_subset = nmxp_chan_subset(channelList, NMXP_DATA_TIMESERIES, params.channels);

    /* Check if some channel already exists */
    if(channelList_subset->number <= 0) {
	nmxp_log(1, 0, "Channels not found!\n");
	return 1;
    }

    /* Free the complete channel list */
    if(channelList) {
	free(channelList);
	channelList = NULL;
    }


84
85
    /* TODO condition starting DAP */
    if(params.start_time != 0   &&   params.end_time != 0) {
86

87
88
89
	/* ************************************************************** */
	/* Start subscription protocol "DATA ACCESS PROTOCOL" version 1.0 */
	/* ************************************************************** */
90

91
92
93
94
95
	/* DAP Step 1: Open a socket */
	if( (naqssock = nmxp_openSocket(params.hostname, params.portnumberdap)) == NMXP_SOCKET_ERROR) {
	    nmxp_log(1, 0, "Error opening socket!\n");
	    return 1;
	}
96

97
98
99
100
101
	/* DAP Step 2: Read connection time */
	if(nmxp_readConnectionTime(naqssock, &connection_time) != NMXP_SOCKET_OK) {
	    nmxp_log(1, 0, "Error reading connection time from server!\n");
	    return 1;
	}
102

103
104
105
106
107
108
109
110
111
112
113
	/* DAP Step 3: Send a ConnectRequest */
	if(nmxp_sendConnectRequest(naqssock, params.datas_username, params.datas_password, connection_time) != NMXP_SOCKET_OK) {
	    nmxp_log(1, 0, "Error sending connect request!\n");
	    return 1;
	}

	/* DAP Step 4: Wait for a Ready message */
	if(nmxp_waitReady(naqssock) != NMXP_SOCKET_OK) {
	    nmxp_log(1, 0, "Error waiting Ready message!\n");
	    return 1;
	}
114

115
116
117
	/* Start loop for sending requests */
	i_chan=0;
	request_SOCKET_OK = NMXP_SOCKET_OK;
118

119
	while(request_SOCKET_OK == NMXP_SOCKET_OK  &&  i_chan < channelList_subset->number) {
120

121
122
	    /* DAP Step 5: Send Data Request */
	    request_SOCKET_OK = nmxp_sendDataRequest(naqssock, channelList_subset->channel[i_chan].key, params.start_time, params.end_time);
123

124
	    if(request_SOCKET_OK == NMXP_SOCKET_OK) {
125

126
127
128
		if(params.flag_writefile) {
		    /* Open output file */
		    sprintf(filename, "%s.%s.%d.%d.%d.nmx", (params.network)? params.network : DEFAULT_NETWORK, channelList_subset->channel[i_chan].name, channelList_subset->channel[i_chan].key, params.start_time, params.end_time);
129

130
131
132
133
134
		    outfile = fopen(filename, "w");

		    if(!outfile) {
			nmxp_log(1, 0, "Can not to open file %s!", filename);
		    }
135
136
137
		}

#ifdef HAVE_LIBMSEED
138
139
140
		if(params.flag_writeseed) {
		    /* Open output Mini-SEED file */
		    sprintf(data_seed.filename_mseed, "%s.%s.%d.%d.%d.miniseed", (params.network)? params.network : DEFAULT_NETWORK, channelList_subset->channel[i_chan].name, channelList_subset->channel[i_chan].key, params.start_time, params.end_time);
141

142
		    data_seed.outfile_mseed = fopen(data_seed.filename_mseed, "w");
143

144
145
146
147
148
		    if(!data_seed.outfile_mseed) {
			nmxp_log(1, 0, "Can not to open file %s!", data_seed.filename_mseed);
		    }
		}
#endif
149

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
		if(params.flag_writefile  &&  outfile) {
		    /* Compute SNCL line */

		    /* Separate station_code and channel_code */
		    station_code = NULL;
		    channel_code = NULL;

		    station_code = strdup(channelList_subset->channel[i_chan].name);
		    if ( (channel_code = strchr(station_code, '.')) == NULL ) {
			nmxp_log(1,0, "Channel name not in STA.CHAN format: %s\n", station_code);
		    }     
		    if(channel_code) {
			*channel_code++ = '\0'; 
		    }     

		    if(station_code) {
			free(station_code);
		    }
168

169
170
		    /* Write SNCL line */
		    fprintf(outfile, "%s.%s.%s.%s\n", station_code, (params.network)? params.network : DEFAULT_NETWORK, channel_code, (params.location)? params.location : "");
171
172
		}

173
174
175
		/* DAP Step 6: Receive Data until receiving a Ready message */
		ret = nmxp_receiveMessage(naqssock, &type, &buffer, &length);
		nmxp_log(0, 1, "ret = %d, type = %d\n", ret, type);
176

177
		while(ret == NMXP_SOCKET_OK   &&    type != NMXP_MSG_READY) {
178

179
180
		    /* Process a packet and return value in NMXP_DATA_PROCESS structure */
		    pd = nmxp_processCompressedDataFunc(buffer, length, channelList_subset);
181
182

#ifdef HAVE_LIBMSEED
183
184
		    /* Write Mini-SEED record */
		    if(params.flag_writeseed) {
185

186
			nmxp_data_msr_pack(pd, &data_seed);
187

188
		    }
189
190
#endif

191
#ifdef HAVE___SRC_SEEDLINK_PLUGIN_C
192
193
		    /* Send data to SeedLink Server */
		    if(params.flag_writeseedlink) {
194

195
196
197
			/* TODO Set values */
			const int usec_correction = 0;
			const int timing_quality = 100;
198

199
200
			send_raw_depoch(pd->station, pd->channel, pd->time, usec_correction, timing_quality,
				pd->pDataPtr, pd->nSamp);
201

202
		    }
203
204
#endif

205
206
207
208
209
210
211
212
213
214
215
216
		    /* Log contents of last packet */
		    nmxp_data_log(pd);

		    if(params.flag_writefile  &&  outfile) {
			/* Write buffer to the output file */
			if(outfile && buffer && length > 0) {
			    int length_int = length;
			    nmxp_data_swap_4b((int32_t *) &length_int);
			    fwrite(&length_int, sizeof(length_int), 1, outfile);
			    fwrite(buffer, length, 1, outfile);
			}
		    }
217

218
219
		    if(buffer) {
			free(buffer);
220
		    }
221
222
223
224

		    /* Receive Data */
		    ret = nmxp_receiveMessage(naqssock, &type, &buffer, &length);
		    nmxp_log(0, 1, "ret = %d, type = %d\n", ret, type);
225
226
		}

227
228
229
		if(params.flag_writefile  &&  outfile) {
		    /* Close output file */
		    fclose(outfile);
230
231
		}

232
233
234
235
236
237
#ifdef HAVE_LIBMSEED
		if(params.flag_writeseed  &&  data_seed.outfile_mseed) {
		    /* Close output Mini-SEED file */
		    fclose(data_seed.outfile_mseed);
		}
#endif
238
239

	    }
240
241
242
	    i_chan++;
	}
	/* DAP Step 7: Repeat steps 5 and 6 for each data request */
243

244
245
246
247
248
249
250
251
252
253
254
	/* DAP Step 8: Send a Terminate message (optional) */
	nmxp_sendTerminateSubscription(naqssock, NMXP_SHUTDOWN_NORMAL, "Bye!");

	/* DAP Step 9: Close the socket */
	nmxp_closeSocket(naqssock);

	/* ************************************************************ */
	/* End subscription protocol "DATA ACCESS PROTOCOL" version 1.0 */
	/* ************************************************************ */

    } else {
255

256
257
258
259
260
261
262
263
264
	/* ************************************************************* */
	/* Start subscription protocol "PRIVATE DATA STREAM" version 1.4 */
	/* ************************************************************* */

	/* PDS Step 1: Open a socket */
	naqssock = nmxp_openSocket(params.hostname, params.portnumberpds);

	if(naqssock == NMXP_SOCKET_ERROR) {
	    return 1;
265
266
	}

267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
	/* PDS Step 2: Send a Connect */
	if(nmxp_sendConnect(naqssock) != NMXP_SOCKET_OK) {
	    printf("Error on sendConnect()\n");
	    return 1;
	}

	/* PDS Step 3: Receive ChannelList */
	if(nmxp_receiveChannelList(naqssock, &channelList) != NMXP_SOCKET_OK) {
	    printf("Error on receiveChannelList()\n");
	    return 1;
	}

	/* Get a subset of channel from arguments */
	channelList_subset = nmxp_chan_subset(channelList, NMXP_DATA_TIMESERIES, params.channels);


	/* PDS Step 4: Send a Request Pending (optional) */
284
285


286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
	/* PDS Step 5: Send AddChannels */
	/* Request Data */
	nmxp_sendAddTimeSeriesChannel(naqssock, channelList_subset, params.stc, params.rate, (params.flag_buffered)? NMXP_BUFFER_YES : NMXP_BUFFER_NO);

	/* PDS Step 6: Repeat until finished: receive and handle packets */

	while(1) {
	    /* Process Compressed or Decompressed Data */
	    nmxp_receiveData(naqssock, channelList_subset, &nmxp_data_log);
	}

	/* PDS Step 7: Send Terminate Subscription */
	nmxp_sendTerminateSubscription(naqssock, NMXP_SHUTDOWN_NORMAL, "Good Bye!");

	/* PDS Step 8: Close the socket */
	nmxp_closeSocket(naqssock);

	/* *********************************************************** */
	/* End subscription protocol "PRIVATE DATA STREAM" version 1.4 */
	/* *********************************************************** */

    }
308
309
310
311
312
313
314
315
316
317


    return 0;
}